ctkbox.c

Bug Summary

File:	ctk/ctkbox.c
Warning:	line 1020, column 40 Assigned value is garbage or undefined
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 ctkbox.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.5" -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/14/../../../../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.deadcode.UnreachableCode -analyzer-checker alpha.core.CastSize -analyzer-checker alpha.core.CastToStruct -analyzer-checker alpha.core.IdenticalExpr -analyzer-checker alpha.security.ArrayBoundV2 -analyzer-checker alpha.security.MallocOverflow -analyzer-checker alpha.security.ReturnPtrRange -analyzer-checker alpha.unix.SimpleStream -analyzer-checker alpha.unix.cstring.BufferOverlap -analyzer-checker alpha.unix.cstring.NotNullTerminated -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/2024-12-18-090527-43637-1 -x c ctkbox.c
1/* CTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
*/

18/*
* Modified by the CTK+ Team and others 1997-2000.  See the AUTHORS
* file for a list of people on the CTK+ Team.  See the ChangeLog
* files for a list of changes.  These files are distributed with
* CTK+ at ftp://ftp.ctk.org/pub/ctk/.
*/

25/**
* SECTION:ctkbox
* @Short_description: A container for packing widgets in a single row or column
* @Title: CtkBox
* @See_also: #CtkGrid
*
* The CtkBox widget arranges child widgets into a single row or column,
* depending upon the value of its #CtkOrientable:orientation property. Within
* the other dimension, all children are allocated the same size. Of course,
* the #CtkWidget:halign and #CtkWidget:valign properties can be used on
* the children to influence their allocation.
*
* CtkBox uses a notion of packing. Packing refers
* to adding widgets with reference to a particular position in a
* #CtkContainer. For a CtkBox, there are two reference positions: the
* start and the end of the box.
* For a vertical #CtkBox, the start is defined as the top of the box and
* the end is defined as the bottom. For a horizontal #CtkBox the start
* is defined as the left side and the end is defined as the right side.
*
* Use repeated calls to ctk_box_pack_start() to pack widgets into a
* CtkBox from start to end. Use ctk_box_pack_end() to add widgets from
* end to start. You may intersperse these calls and add widgets from
* both ends of the same CtkBox.
*
* Because CtkBox is a #CtkContainer, you may also use ctk_container_add()
* to insert widgets into the box, and they will be packed with the default
* values for expand and fill child properties. Use ctk_container_remove()
* to remove widgets from the CtkBox.
*
* Use ctk_box_set_homogeneous() to specify whether or not all children
* of the CtkBox are forced to get the same amount of space.
*
* Use ctk_box_set_spacing() to determine how much space will be
* minimally placed between all children in the CtkBox. Note that
* spacing is added between the children, while
* padding added by ctk_box_pack_start() or ctk_box_pack_end() is added
* on either side of the widget it belongs to.
*
* Use ctk_box_reorder_child() to move a CtkBox child to a different
* place in the box.
*
* Use ctk_box_set_child_packing() to reset the expand,
* fill and padding child properties.
* Use ctk_box_query_child_packing() to query these fields.
*
* # CSS nodes
*
* CtkBox uses a single CSS node with name box.
*
* In horizontal orientation, the nodes of the children are always arranged
* from left to right. So :first-child will always select the leftmost child,
* regardless of text direction.
*/

80#include "config.h"

82#include "ctkbox.h"
83#include "ctkboxprivate.h"
84#include "ctkcontainerprivate.h"
85#include "ctkcsscustomgadgetprivate.h"
86#include "ctkcssnodeprivate.h"
87#include "ctkintl.h"
88#include "ctkorientable.h"
89#include "ctkorientableprivate.h"
90#include "ctkprivate.h"
91#include "ctktypebuiltins.h"
92#include "ctksizerequest.h"
93#include "ctkwidgetpath.h"
94#include "ctkwidgetprivate.h"
95#include "a11y/ctkcontaineraccessible.h"


98enum {
PROP_0,
PROP_SPACING,
PROP_HOMOGENEOUS,
PROP_BASELINE_POSITION,

/* orientable */
PROP_ORIENTATION,
LAST_PROP = PROP_ORIENTATION
107};

109enum {
CHILD_PROP_0,
CHILD_PROP_EXPAND,
CHILD_PROP_FILL,
CHILD_PROP_PADDING,
CHILD_PROP_PACK_TYPE,
CHILD_PROP_POSITION,
LAST_CHILD_PROP
117};

119typedef struct _CtkBoxChild        CtkBoxChild;

121struct _CtkBoxPrivate
122{
GList          *children;
CtkBoxChild    *center;
CtkCssGadget   *gadget;

CtkOrientation  orientation;
gint16          spacing;

guint           default_expand : 1;
guint           homogeneous    : 1;
guint           spacing_set    : 1;
guint           baseline_pos   : 2;
134};

136static GParamSpec *props[LAST_PROP] = { NULL((void*)0), };
137static GParamSpec *child_props[LAST_CHILD_PROP] = { NULL((void*)0), };

139/*
* CtkBoxChild:
* @widget: the child widget, packed into the CtkBox.
* @padding: the number of extra pixels to put between this child and its
*  neighbors, set when packed, zero by default.
* @expand: flag indicates whether extra space should be given to this child.
*  Any extra space given to the parent CtkBox is divided up among all children
*  with this attribute set to %TRUE; set when packed, %TRUE by default.
* @fill: flag indicates whether any extra space given to this child due to its
*  @expand attribute being set is actually allocated to the child, rather than
*  being used as padding around the widget; set when packed, %TRUE by default.
* @pack: one of #CtkPackType indicating whether the child is packed with
*  reference to the start (top/left) or end (bottom/right) of the CtkBox.
*/
153struct _CtkBoxChild
154{
CtkWidget *widget;

guint16    padding;

guint      expand : 1;
guint      fill   : 1;
guint      pack   : 1;
162};

164static void ctk_box_size_allocate         (CtkWidget              *widget,
                                         CtkAllocation          *allocation);
166static gboolean ctk_box_draw           (CtkWidget        *widget,
                                      cairo_t          *cr);

169static void ctk_box_direction_changed  (CtkWidget        *widget,
                                      CtkTextDirection  previous_direction);

172static void ctk_box_set_property       (GObject        *object,
                                      guint           prop_id,
                                      const GValue   *value,
                                      GParamSpec     *pspec);
176static void ctk_box_get_property       (GObject        *object,
                                      guint           prop_id,
                                      GValue         *value,
                                      GParamSpec     *pspec);
180static void ctk_box_add                (CtkContainer   *container,
                                      CtkWidget      *widget);
182static void ctk_box_remove             (CtkContainer   *container,
                                      CtkWidget      *widget);
184static void ctk_box_forall             (CtkContainer   *container,
                                      gboolean        include_internals,
                                      CtkCallback     callback,
                                      gpointer        callback_data);
188static void ctk_box_set_child_property (CtkContainer   *container,
                                      CtkWidget      *child,
                                      guint           property_id,
                                      const GValue   *value,
                                      GParamSpec     *pspec);
193static void ctk_box_get_child_property (CtkContainer   *container,
                                      CtkWidget      *child,
                                      guint           property_id,
                                      GValue         *value,
                                      GParamSpec     *pspec);
198static GType ctk_box_child_type        (CtkContainer   *container);
199static CtkWidgetPath * ctk_box_get_path_for_child
                                     (CtkContainer   *container,
                                      CtkWidget      *child);


204static void               ctk_box_get_preferred_width            (CtkWidget           *widget,
                                                                gint                *minimum_size,
                                                                gint                *natural_size);
207static void               ctk_box_get_preferred_height           (CtkWidget           *widget,
                                                                gint                *minimum_size,
                                                                gint                *natural_size);
210static void               ctk_box_get_preferred_width_for_height (CtkWidget           *widget,
                                                                gint                 height,
                                                                gint                *minimum_width,
                                                                gint                *natural_width);
214static void               ctk_box_get_preferred_height_for_width (CtkWidget           *widget,
                                                                gint                 width,
                                                                gint                *minimum_height,
                                                                gint                *natural_height);
218static void  ctk_box_get_preferred_height_and_baseline_for_width (CtkWidget           *widget,
						  gint                 width,
						  gint                *minimum_height,
						  gint                *natural_height,
						  gint                *minimum_baseline,
						  gint                *natural_baseline);

225static void               ctk_box_buildable_init                 (CtkBuildableIface  *iface);

227G_DEFINE_TYPE_WITH_CODE (CtkBox, ctk_box, CTK_TYPE_CONTAINER,static void ctk_box_init (CtkBox *self); static void ctk_box_class_init
 (CtkBoxClass *klass); static GType ctk_box_get_type_once (void
); static gpointer ctk_box_parent_class = ((void*)0); static gint
 CtkBox_private_offset; static void ctk_box_class_intern_init
 (gpointer klass) { ctk_box_parent_class = g_type_class_peek_parent
 (klass); if (CtkBox_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkBox_private_offset); ctk_box_class_init ((CtkBoxClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
 ctk_box_get_instance_private (CtkBox *self) { return (((gpointer
) ((guint8*) (self) + (glong) (CtkBox_private_offset)))); } GType
 ctk_box_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
) (0 ? (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_box_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_box_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkBox"), sizeof (CtkBoxClass)
, (GClassInitFunc)(void (*)(void)) ctk_box_class_intern_init,
 sizeof (CtkBox), (GInstanceInitFunc)(void (*)(void)) ctk_box_init
, (GTypeFlags) 0); { {{ CtkBox_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkBoxPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ((void*)0), ((void*)0), ((void*)0) }; g_type_add_interface_static
 (g_define_type_id, (ctk_orientable_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) ctk_box_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 (CtkBox)static void ctk_box_init (CtkBox *self); static void ctk_box_class_init
 (CtkBoxClass *klass); static GType ctk_box_get_type_once (void
); static gpointer ctk_box_parent_class = ((void*)0); static gint
 CtkBox_private_offset; static void ctk_box_class_intern_init
 (gpointer klass) { ctk_box_parent_class = g_type_class_peek_parent
 (klass); if (CtkBox_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkBox_private_offset); ctk_box_class_init ((CtkBoxClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
 ctk_box_get_instance_private (CtkBox *self) { return (((gpointer
) ((guint8*) (self) + (glong) (CtkBox_private_offset)))); } GType
 ctk_box_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
) (0 ? (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_box_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_box_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkBox"), sizeof (CtkBoxClass)
, (GClassInitFunc)(void (*)(void)) ctk_box_class_intern_init,
 sizeof (CtkBox), (GInstanceInitFunc)(void (*)(void)) ctk_box_init
, (GTypeFlags) 0); { {{ CtkBox_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkBoxPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ((void*)0), ((void*)0), ((void*)0) }; g_type_add_interface_static
 (g_define_type_id, (ctk_orientable_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) ctk_box_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_ORIENTABLE, NULL)static void ctk_box_init (CtkBox *self); static void ctk_box_class_init
 (CtkBoxClass *klass); static GType ctk_box_get_type_once (void
); static gpointer ctk_box_parent_class = ((void*)0); static gint
 CtkBox_private_offset; static void ctk_box_class_intern_init
 (gpointer klass) { ctk_box_parent_class = g_type_class_peek_parent
 (klass); if (CtkBox_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkBox_private_offset); ctk_box_class_init ((CtkBoxClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
 ctk_box_get_instance_private (CtkBox *self) { return (((gpointer
) ((guint8*) (self) + (glong) (CtkBox_private_offset)))); } GType
 ctk_box_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
) (0 ? (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_box_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_box_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkBox"), sizeof (CtkBoxClass)
, (GClassInitFunc)(void (*)(void)) ctk_box_class_intern_init,
 sizeof (CtkBox), (GInstanceInitFunc)(void (*)(void)) ctk_box_init
, (GTypeFlags) 0); { {{ CtkBox_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkBoxPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ((void*)0), ((void*)0), ((void*)0) }; g_type_add_interface_static
 (g_define_type_id, (ctk_orientable_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) ctk_box_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, ctk_box_buildable_init))static void ctk_box_init (CtkBox *self); static void ctk_box_class_init
 (CtkBoxClass *klass); static GType ctk_box_get_type_once (void
); static gpointer ctk_box_parent_class = ((void*)0); static gint
 CtkBox_private_offset; static void ctk_box_class_intern_init
 (gpointer klass) { ctk_box_parent_class = g_type_class_peek_parent
 (klass); if (CtkBox_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkBox_private_offset); ctk_box_class_init ((CtkBoxClass
*) klass); } __attribute__ ((__unused__)) static inline gpointer
 ctk_box_get_instance_private (CtkBox *self) { return (((gpointer
) ((guint8*) (self) + (glong) (CtkBox_private_offset)))); } GType
 ctk_box_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
) (0 ? (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_box_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_box_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkBox"), sizeof (CtkBoxClass)
, (GClassInitFunc)(void (*)(void)) ctk_box_class_intern_init,
 sizeof (CtkBox), (GInstanceInitFunc)(void (*)(void)) ctk_box_init
, (GTypeFlags) 0); { {{ CtkBox_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkBoxPrivate)); } { const GInterfaceInfo
 g_implement_interface_info = { (GInterfaceInitFunc)(void (*)
(void)) ((void*)0), ((void*)0), ((void*)0) }; g_type_add_interface_static
 (g_define_type_id, (ctk_orientable_get_type ()), &g_implement_interface_info
); } { const GInterfaceInfo g_implement_interface_info = { (GInterfaceInitFunc
)(void (*)(void)) ctk_box_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
; }

232static void
233ctk_box_dispose (GObject *object)
234{
CtkBox *box = CTK_BOX (object)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *priv = box->priv;

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_box_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_box_parent_class)), (((GType) ((20) << (2)))))
)))->dispose (object);
241}

243static void
244ctk_box_class_init (CtkBoxClass *class)
245{
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->set_property = ctk_box_set_property;
object_class->get_property = ctk_box_get_property;
object_class->dispose = ctk_box_dispose;

widget_class->draw                           = ctk_box_draw;
widget_class->size_allocate                  = ctk_box_size_allocate;
widget_class->get_preferred_width            = ctk_box_get_preferred_width;
widget_class->get_preferred_height           = ctk_box_get_preferred_height;
widget_class->get_preferred_height_for_width = ctk_box_get_preferred_height_for_width;
widget_class->get_preferred_height_and_baseline_for_width = ctk_box_get_preferred_height_and_baseline_for_width;
widget_class->get_preferred_width_for_height = ctk_box_get_preferred_width_for_height;
widget_class->direction_changed              = ctk_box_direction_changed;

container_class->add = ctk_box_add;
container_class->remove = ctk_box_remove;
container_class->forall = ctk_box_forall;
container_class->child_type = ctk_box_child_type;
container_class->set_child_property = ctk_box_set_child_property;
container_class->get_child_property = ctk_box_get_child_property;
container_class->get_path_for_child = ctk_box_get_path_for_child;
ctk_container_class_handle_border_width (container_class);

g_object_class_override_property (object_class,
                                  PROP_ORIENTATION,
                                  "orientation");

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, 0,
                    CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

props[PROP_HOMOGENEOUS] =
  g_param_spec_boolean ("homogeneous",
                        P_("Homogeneous")g_dgettext("ctk30" "-properties","Homogeneous"),
                        P_("Whether the children should all be the same size")g_dgettext("ctk30" "-properties","Whether the children should all be the same size"
),
                        FALSE(0),
                        CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

props[PROP_BASELINE_POSITION] =
  g_param_spec_enum ("baseline-position",
                     P_("Baseline position")g_dgettext("ctk30" "-properties","Baseline position"),
                     P_("The position of the baseline aligned widgets if extra space is available")g_dgettext("ctk30" "-properties","The position of the baseline aligned widgets if extra space is available"
),
                     CTK_TYPE_BASELINE_POSITION(ctk_baseline_position_get_type ()),
                     CTK_BASELINE_POSITION_CENTER,
                     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, props);

/**
 * CtkBox:expand:
 *
 * Whether the child should receive extra space when the parent grows.
 *
 * Note that the default value for this property is %FALSE for CtkBox,
 * but #CtkHBox, #CtkVBox and other subclasses use the old default
 * of %TRUE.
 *
 * Note: The #CtkWidget:hexpand or #CtkWidget:vexpand properties are the
 * preferred way to influence whether the child receives extra space, by
 * setting the child’s expand property corresponding to the box’s orientation.
 *
 * In contrast to #CtkWidget:hexpand, the expand child property does
 * not cause the box to expand itself.
 */
child_props[CHILD_PROP_EXPAND] =
    g_param_spec_boolean ("expand",
                          P_("Expand")g_dgettext("ctk30" "-properties","Expand"),
                          P_("Whether the child should receive extra space when the parent grows")g_dgettext("ctk30" "-properties","Whether the child should receive extra space when the parent grows"
),
                          FALSE(0),
                          CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

/**
 * CtkBox:fill:
 *
 * Whether the child should fill extra space or use it as padding.
 *
 * Note: The #CtkWidget:halign or #CtkWidget:valign properties are the
 * preferred way to influence whether the child fills available space, by
 * setting the child’s align property corresponding to the box’s orientation
 * to %CTK_ALIGN_FILL to fill, or to something else to refrain from filling.
 */
child_props[CHILD_PROP_FILL] =
    g_param_spec_boolean ("fill",
                          P_("Fill")g_dgettext("ctk30" "-properties","Fill"),
                          P_("Whether extra space given to the child should be allocated to the child or used as padding")g_dgettext("ctk30" "-properties","Whether extra space given to the child should be allocated to the child or used as padding"
),
                          TRUE(!(0)),
                          CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

/**
 * CtkBox:padding:
 *
 * Extra space to put between the child and its neighbors, in pixels.
 *
 * Note: The CSS padding properties are the preferred way to add space among
 * widgets, by setting the paddings corresponding to the box’s orientation.
 */
child_props[CHILD_PROP_PADDING] =
    g_param_spec_uint ("padding",
                       P_("Padding")g_dgettext("ctk30" "-properties","Padding"),
                       P_("Extra space to put between the child and its neighbors, in pixels")g_dgettext("ctk30" "-properties","Extra space to put between the child and its neighbors, in pixels"
),
                       0, G_MAXINT2147483647,
                       0,
                       CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

child_props[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);

child_props[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);

ctk_container_class_install_child_properties (container_class, LAST_CHILD_PROP, child_props);

ctk_widget_class_set_accessible_role (widget_class, ATK_ROLE_FILLER);
ctk_widget_class_set_css_name (widget_class, "box");
375}

377static void
378ctk_box_set_property (GObject      *object,
                    guint         prop_id,
                    const GValue *value,
                    GParamSpec   *pspec)
382{
CtkBox *box = CTK_BOX (object)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *private = box->priv;

switch (prop_id)
  {
  case PROP_ORIENTATION:
    {
      CtkOrientation orientation = g_value_get_enum (value);
      if (private->orientation != orientation)
        {
          private->orientation = orientation;
          _ctk_orientable_set_style_classes (CTK_ORIENTABLE (box)((((CtkOrientable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_orientable_get_type ())))))));
          ctk_widget_queue_resize (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ())))))));
          g_object_notify (object, "orientation");
        }
    }
    break;
  case PROP_SPACING:
    ctk_box_set_spacing (box, g_value_get_int (value));
    break;
  case PROP_BASELINE_POSITION:
    ctk_box_set_baseline_position (box, g_value_get_enum (value));
    break;
  case PROP_HOMOGENEOUS:
    ctk_box_set_homogeneous (box, 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'"
, "ctkbox.c", 410, ("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;
  }
413}

415static void
416ctk_box_get_property (GObject    *object,
                    guint       prop_id,
                    GValue     *value,
                    GParamSpec *pspec)
420{
CtkBox *box = CTK_BOX (object)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *private = box->priv;

switch (prop_id)
  {
  case PROP_ORIENTATION:
    g_value_set_enum (value, private->orientation);
    break;
  case PROP_SPACING:
    g_value_set_int (value, private->spacing);
    break;
  case PROP_BASELINE_POSITION:
    g_value_set_enum (value, private->baseline_pos);
    break;
  case PROP_HOMOGENEOUS:
    g_value_set_boolean (value, private->homogeneous);
    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'"
, "ctkbox.c", 439, ("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;
  }
442}

444static gboolean
445ctk_box_draw_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__)))
452{
CTK_WIDGET_CLASS (ctk_box_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_box_parent_class)), ((ctk_widget_get_type ()))))))->draw (ctk_css_gadget_get_owner (gadget), cr);

return FALSE(0);
456}

458static gboolean
459ctk_box_draw (CtkWidget *widget,
            cairo_t   *cr)
461{
ctk_css_gadget_draw (CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))))->priv->gadget, cr);

return FALSE(0);
465}


468static void
469count_expand_children (CtkBox *box,
                     gint *visible_children,
                     gint *expand_children)
472{
CtkBoxPrivate  *private = box->priv;
GList       *children;
CtkBoxChild *child;

*visible_children = *expand_children = 0;

for (children = private->children; children; children = children->next)
  {
    child = children->data;

    if (_ctk_widget_get_visible (child->widget))
{
 *visible_children += 1;
 if (child->expand || ctk_widget_compute_expand (child->widget, private->orientation))
   *expand_children += 1;
}
  }
490}

492static void
493ctk_box_size_allocate_no_center (CtkWidget           *widget,
                               const CtkAllocation *allocation)
495{
CtkBox *box = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *private = box->priv;
CtkBoxChild *child;
GList *children;
gint nvis_children;
gint nexpand_children;

CtkTextDirection direction;
CtkAllocation child_allocation;
CtkRequestedSize *sizes;
gint child_minimum_baseline, child_natural_baseline;
gint minimum_above, natural_above;
gint minimum_below, natural_below;
gboolean have_baseline;
gint baseline;

CtkPackType packing;

gint size;
gint extra;
gint n_extra_widgets = 0; /* Number of widgets that receive 1 extra px */
gint x = 0, y = 0, i;
gint child_size;


count_expand_children (box, &nvis_children, &nexpand_children);

/* If there is no visible child, simply return. */
if (nvis_children <= 0)
  return;

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

if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
  size = allocation->width - (nvis_children - 1) * private->spacing;
else
  size = allocation->height - (nvis_children - 1) * private->spacing;

have_baseline = FALSE(0);
minimum_above = natural_above = 0;
minimum_below = natural_below = 0;

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

    if (!_ctk_widget_get_visible (child->widget))
continue;

    if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
ctk_widget_get_preferred_width_for_height (child->widget,
                                                 allocation->height,
                                                 &sizes[i].minimum_size,
                                                 &sizes[i].natural_size);
    else
ctk_widget_get_preferred_height_and_baseline_for_width (child->widget,
						allocation->width,
						&sizes[i].minimum_size,
						&sizes[i].natural_size,
						NULL((void*)0), NULL((void*)0));

    /* Assert the api is working properly */
    if (sizes[i].minimum_size < 0)
g_error ("CtkBox child %s minimum %s: %d < 0 for %s %d",
 ctk_widget_get_name (CTK_WIDGET (child->widget)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child->widget)), ((ctk_widget_get_type ()))))))),
 (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? "width" : "height",
 sizes[i].minimum_size,
 (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? "height" : "width",
 (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? allocation->height : allocation->width);

    if (sizes[i].natural_size < sizes[i].minimum_size)
g_error ("CtkBox child %s natural %s: %d < minimum %d for %s %d",
 ctk_widget_get_name (CTK_WIDGET (child->widget)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child->widget)), ((ctk_widget_get_type ()))))))),
 (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? "width" : "height",
 sizes[i].natural_size,
 sizes[i].minimum_size,
 (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? "height" : "width",
 (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? allocation->height : allocation->width);

    size -= sizes[i].minimum_size;
    size -= child->padding * 2;

    sizes[i].data = child;

    i++;
  }

if (private->homogeneous)
  {
    /* If were homogenous we still need to run the above loop to get the
     * minimum sizes for children that are not going to fill
     */
    if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
size = allocation->width - (nvis_children - 1) * private->spacing;
    else
size = allocation->height - (nvis_children - 1) * private->spacing;

    extra = size / nvis_children;
    n_extra_widgets = size % nvis_children;
  }
else
  {
    /* Bring children up to size first */
    size = ctk_distribute_natural_allocation (MAX (0, size)(((0) > (size)) ? (0) : (size)), nvis_children, sizes);

    /* Calculate space which hasn't distributed yet,
     * and is available for expanding children.
     */
    if (nexpand_children > 0)
{
 extra = size / nexpand_children;
 n_extra_widgets = size % nexpand_children;
}
    else
extra = 0;
  }

/* Allocate child sizes. */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; ++packing)
  {
    for (i = 0, children = private->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 != packing)
   {
     i++;
     continue;
   }

 /* Assign the child's size. */
 if (private->homogeneous)
   {
     child_size = extra;

     if (n_extra_widgets > 0)
{
  child_size++;
  n_extra_widgets--;
}
   }
 else
   {
     child_size = sizes[i].minimum_size + child->padding * 2;

     if (child->expand || ctk_widget_compute_expand (child->widget, private->orientation))
{
  child_size += extra;

  if (n_extra_widgets > 0)
    {
      child_size++;
      n_extra_widgets--;
    }
}
   }

 sizes[i].natural_size = child_size;

 if (private->orientation == CTK_ORIENTATION_HORIZONTAL &&
     ctk_widget_get_valign_with_baseline (child->widget) == CTK_ALIGN_BASELINE)
   {
     int child_allocation_width;
     int child_minimum_height, child_natural_height;

     if (child->fill)
child_allocation_width = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
     else
child_allocation_width = sizes[i].minimum_size;

     child_minimum_baseline = -1;
     child_natural_baseline = -1;
     ctk_widget_get_preferred_height_and_baseline_for_width (child->widget,
						      child_allocation_width,
						      &child_minimum_height, &child_natural_height,
						      &child_minimum_baseline, &child_natural_baseline);

     if (child_minimum_baseline >= 0)
{
  have_baseline = TRUE(!(0));
  minimum_below = MAX (minimum_below, child_minimum_height - child_minimum_baseline)(((minimum_below) > (child_minimum_height - child_minimum_baseline
)) ? (minimum_below) : (child_minimum_height - child_minimum_baseline
));
  natural_below = MAX (natural_below, child_natural_height - child_natural_baseline)(((natural_below) > (child_natural_height - child_natural_baseline
)) ? (natural_below) : (child_natural_height - child_natural_baseline
));
  minimum_above = MAX (minimum_above, child_minimum_baseline)(((minimum_above) > (child_minimum_baseline)) ? (minimum_above
) : (child_minimum_baseline));
  natural_above = MAX (natural_above, child_natural_baseline)(((natural_above) > (child_natural_baseline)) ? (natural_above
) : (child_natural_baseline));
}
   }

 i++;
}
  }

baseline = ctk_widget_get_allocated_baseline (widget);
if (baseline == -1 && have_baseline)
  {
    gint height = MAX (1, allocation->height)(((1) > (allocation->height)) ? (1) : (allocation->height
));

    /* TODO: This is purely based on the minimum baseline, when things fit we should
use the natural one? */

    switch (private->baseline_pos)
{
case CTK_BASELINE_POSITION_TOP:
 baseline = minimum_above;
 break;
case CTK_BASELINE_POSITION_CENTER:
 baseline = minimum_above + (height - (minimum_above + minimum_below)) / 2;
 break;
case CTK_BASELINE_POSITION_BOTTOM:
 baseline = height - minimum_below;
 break;
}
  }

/* Allocate child positions. */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; ++packing)
  {
    if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
{
 child_allocation.y = allocation->y;
 child_allocation.height = MAX (1, allocation->height)(((1) > (allocation->height)) ? (1) : (allocation->height
));
 if (packing == CTK_PACK_START)
   x = allocation->x;
 else
   x = allocation->x + allocation->width;
}
    else
{
 child_allocation.x = allocation->x;
 child_allocation.width = MAX (1, allocation->width)(((1) > (allocation->width)) ? (1) : (allocation->width
));
 if (packing == CTK_PACK_START)
   y = allocation->y;
 else
   y = allocation->y + allocation->height;
}

    for (i = 0, children = private->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 != packing)
   {
     i++;
     continue;
   }

 child_size = sizes[i].natural_size;

 /* Assign the child's position. */
 if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
   {
     if (child->fill)
{
  child_allocation.width = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
  child_allocation.x = x + child->padding;
}
     else
{
  child_allocation.width = sizes[i].minimum_size;
  child_allocation.x = x + (child_size - child_allocation.width) / 2;
}

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

  child_allocation.x -= child_size;
}

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

   }
 else /* (private->orientation == CTK_ORIENTATION_VERTICAL) */
   {
     if (child->fill)
{
  child_allocation.height = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
  child_allocation.y = y + child->padding;
}
     else
{
  child_allocation.height = sizes[i].minimum_size;
  child_allocation.y = y + (child_size - child_allocation.height) / 2;
}

     if (packing == CTK_PACK_START)
{
  y += child_size + private->spacing;
}
     else
{
  y -= child_size + private->spacing;

  child_allocation.y -= child_size;
}
   }
 ctk_widget_size_allocate_with_baseline (child->widget, &child_allocation, baseline);

 i++;
}
  }

_ctk_widget_set_simple_clip (widget, NULL((void*)0));
824}

826static void
827ctk_box_size_allocate_with_center (CtkWidget           *widget,
                                 const CtkAllocation *allocation)
829{
CtkBox *box = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *priv = box->priv;
CtkBoxChild *child;
GList *children;
gint nvis[2];
gint nexp[2];
CtkTextDirection direction;
CtkAllocation child_allocation;
CtkRequestedSize *sizes[2];
CtkRequestedSize center_req = {.minimum_size = 0, .natural_size = 0};
gint child_minimum_baseline, child_natural_baseline;
gint minimum_above, natural_above;
gint minimum_below, natural_below;
gboolean have_baseline;
gint baseline;
gint idx[2];
gint center_pos;
gint center_size;
gint box_size;
gint side[2];
CtkPackType packing;
gint min_size[2];
gint nat_size[2];
gint extra[2];
gint n_extra_widgets[2];
gint x = 0, y = 0, i;
gint child_size;

nvis[0] = nvis[1] = 0;
nexp[0] = nexp[1] = 0;
for (children = priv->children; children; children = children->next)
1
Loop condition is true.  Entering loop body→
8
←
Loop condition is false. Execution continues on line 873→
  {
    child = children->data;

    if (child != priv->center &&
2
←
Assuming 'child' is not equal to field 'center'→
4
←
Taking true branch→
        _ctk_widget_get_visible (child->widget))
3
←
Assuming the condition is true→
      {
        nvis[child->pack] += 1;
        if (child->expand || ctk_widget_compute_expand (child->widget, priv->orientation))
5
←
Assuming field 'expand' is 0→
6
←
Assuming the condition is false→
7
←
Taking false branch→
          nexp[child->pack] += 1;
      }
  }

direction = ctk_widget_get_direction (widget);
sizes[0] = g_newa (CtkRequestedSize, nvis[0])((CtkRequestedSize*) __builtin_alloca (sizeof (CtkRequestedSize
) * (gsize) (nvis[0])));
sizes[1] = g_newa (CtkRequestedSize, nvis[1])((CtkRequestedSize*) __builtin_alloca (sizeof (CtkRequestedSize
) * (gsize) (nvis[1])));

if (priv->orientation == CTK_ORIENTATION_HORIZONTAL)
9
←
Assuming field 'orientation' is equal to CTK_ORIENTATION_HORIZONTAL→
10
←
Taking true branch→
  box_size = allocation->width;
else
  box_size = allocation->height;

have_baseline = FALSE(0);
minimum_above = natural_above = 0;
minimum_below = natural_below = 0;

min_size[0] = nat_size[0] = nvis[0] * priv->spacing;
min_size[1] = nat_size[1] = nvis[1] * priv->spacing;

/* Retrieve desired size for visible children. */
idx[0] = idx[1] = 0;
for (children = priv->children; children; children = children->next)
11
←
Loop condition is true.  Entering loop body→
17
←
Loop condition is false. Execution continues on line 929→
  {
    CtkRequestedSize *req;

    child = children->data;

    if (!_ctk_widget_get_visible (child->widget))
12
←
Assuming the condition is false→
13
←
Taking false branch→
continue;

    if (child13.1
'child' is not equal to field 'center'
 == priv->center)
14
←
Taking false branch→
      req = &center_req;
    else
      req = &(sizes[child->pack][idx[child->pack]]);

    if (priv->orientation14.1
Field 'orientation' is equal to CTK_ORIENTATION_HORIZONTAL
 == CTK_ORIENTATION_HORIZONTAL)
15
←
Taking true branch→
      ctk_widget_get_preferred_width_for_height (child->widget,
                                                 allocation->height,
                                                 &req->minimum_size,
                                                 &req->natural_size);
    else
      ctk_widget_get_preferred_height_and_baseline_for_width (child->widget,
                                                              allocation->width,
                                                              &req->minimum_size,
                                                              &req->natural_size,
                                                              NULL((void*)0), NULL((void*)0));

    if (child15.1
'child' is not equal to field 'center'
 != priv->center)
16
←
Taking true branch→
      {
        min_size[child->pack] += req->minimum_size + 2 * child->padding;
        nat_size[child->pack] += req->natural_size + 2 * child->padding;

        idx[child->pack] += 1;
      }

    req->data = child;
  }

/* Determine size of center */
if (priv->center->expand)
18
←
Assuming field 'expand' is not equal to 0→
  center_size = MAX (box_size - 2 * MAX (nat_size[0], nat_size[1]), center_req.minimum_size)(((box_size - 2 * (((nat_size[0]) > (nat_size[1])) ? (nat_size
[0]) : (nat_size[1]))) > (center_req.minimum_size)) ? (box_size
 - 2 * (((nat_size[0]) > (nat_size[1])) ? (nat_size[0]) : (
nat_size[1]))) : (center_req.minimum_size));
19
←
Taking true branch→
20
←
Assuming the condition is false→
21
←
'?' condition is false→
22
←
Assuming the condition is false→
23
←
'?' condition is false→
else
  center_size = MAX (MIN (center_req.natural_size, box_size - min_size[0] - min_size[1]), center_req.minimum_size)((((((center_req.natural_size) < (box_size - min_size[0] -
 min_size[1])) ? (center_req.natural_size) : (box_size - min_size
[0] - min_size[1]))) > (center_req.minimum_size)) ? ((((center_req
.natural_size) < (box_size - min_size[0] - min_size[1])) ?
 (center_req.natural_size) : (box_size - min_size[0] - min_size
[1]))) : (center_req.minimum_size));

if (priv->homogeneous)
24
←
Assuming field 'homogeneous' is not equal to 0→
  {
    extra[0] = nvis[0] ? ((box_size - center_size) / 2 - nvis[0] * priv->spacing) / nvis[0] : 0;
25
←
Taking true branch→
26
←
Assuming the condition is true→
27
←
'?' condition is true→
    extra[1] = nvis[1] ? ((box_size - center_size) / 2 - nvis[1] * priv->spacing) / nvis[1] : 0;
28
←
Assuming the condition is true→
29
←
'?' condition is true→
    extra[0] = MIN (extra[0], extra[1])(((extra[0]) < (extra[1])) ? (extra[0]) : (extra[1]));
30
←
Assuming the condition is false→
31
←
'?' condition is false→
    n_extra_widgets[0] = 0;
  }
else
  {
    for (packing = CTK_PACK_START; packing <= CTK_PACK_END; packing++)
      {
        gint s;
        /* Distribute the remainder naturally on each side */
        s = MIN ((box_size - center_size) / 2 - min_size[packing], box_size - center_size - min_size[0] - min_size[1])((((box_size - center_size) / 2 - min_size[packing]) < (box_size
 - center_size - min_size[0] - min_size[1])) ? ((box_size - center_size
) / 2 - min_size[packing]) : (box_size - center_size - min_size
[0] - min_size[1]));
        s = ctk_distribute_natural_allocation (MAX (0, s)(((0) > (s)) ? (0) : (s)), nvis[packing], sizes[packing]);

        /* Calculate space which hasn't distributed yet,
         * and is available for expanding children.
         */
        if (nexp[packing] > 0)
          {
            extra[packing] = s / nexp[packing];
            n_extra_widgets[packing] = s % nexp[packing];
          }
         else
    extra[packing] = 0;
      }
  }

/* Allocate child sizes. */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; ++packing)
32
←
Loop condition is true.  Entering loop body→
  {
    for (i = 0, children = priv->children; children; children = children->next)
33
←
Loop condition is true.  Entering loop body→
      {
        child = children->data;

        /* If widget is not visible, skip it. */
        if (!_ctk_widget_get_visible (child->widget))
34
←
Assuming the condition is false→
35
←
Taking false branch→
          continue;

        /* Skip the center widget */
        if (child35.1
'child' is not equal to field 'center'
 == priv->center)
36
←
Taking false branch→
          continue;

        /* If widget is packed differently, skip it. */
        if (child->pack != packing)
37
←
Assuming 'packing' is equal to field 'pack'→
38
←
Taking false branch→
          continue;

        /* Assign the child's size. */
        if (priv->homogeneous38.1
Field 'homogeneous' is not equal to 0
)
39
←
Taking true branch→
          {
            child_size = extra[0];

            if (n_extra_widgets[0] > 0)
40
←
Taking false branch→
              {
                child_size++;
                n_extra_widgets[0]--;
              }
          }
        else
          {
            child_size = sizes[packing][i].minimum_size + child->padding * 2;

            if (child->expand || ctk_widget_compute_expand (child->widget, priv->orientation))
              {
                child_size += extra[packing];

                if (n_extra_widgets[packing] > 0)
                  {
                    child_size++;
                    n_extra_widgets[packing]--;
                  }
              }
          }

        sizes[packing][i].natural_size = child_size;

        if (priv->orientation40.1
Field 'orientation' is equal to CTK_ORIENTATION_HORIZONTAL
 == CTK_ORIENTATION_HORIZONTAL &&
42
←
Taking true branch→
            ctk_widget_get_valign_with_baseline (child->widget) == CTK_ALIGN_BASELINE)
41
←
Assuming the condition is true→
          {
            gint child_allocation_width;
     gint child_minimum_height, child_natural_height;

            if (child->fill)
43
←
Assuming field 'fill' is 0→
44
←
Taking false branch→
              child_allocation_width = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
            else
              child_allocation_width = sizes[packing][i].minimum_size;
45
←
Assigned value is garbage or undefined

            child_minimum_baseline = -1;
            child_natural_baseline = -1;
            ctk_widget_get_preferred_height_and_baseline_for_width (child->widget,
                                                                    child_allocation_width,
                                                                    &child_minimum_height, &child_natural_height,
                                                                    &child_minimum_baseline, &child_natural_baseline);

            if (child_minimum_baseline >= 0)
              {
                have_baseline = TRUE(!(0));
                minimum_below = MAX (minimum_below, child_minimum_height - child_minimum_baseline)(((minimum_below) > (child_minimum_height - child_minimum_baseline
)) ? (minimum_below) : (child_minimum_height - child_minimum_baseline
));
                natural_below = MAX (natural_below, child_natural_height - child_natural_baseline)(((natural_below) > (child_natural_height - child_natural_baseline
)) ? (natural_below) : (child_natural_height - child_natural_baseline
));
                minimum_above = MAX (minimum_above, child_minimum_baseline)(((minimum_above) > (child_minimum_baseline)) ? (minimum_above
) : (child_minimum_baseline));
                natural_above = MAX (natural_above, child_natural_baseline)(((natural_above) > (child_natural_baseline)) ? (natural_above
) : (child_natural_baseline));
              }
          }

        i++;
      }
  }

baseline = ctk_widget_get_allocated_baseline (widget);
if (baseline == -1 && have_baseline)
  {
    gint height = MAX (1, allocation->height)(((1) > (allocation->height)) ? (1) : (allocation->height
));

   /* TODO: This is purely based on the minimum baseline, when things fit we should
    * use the natural one?
    */
    switch (priv->baseline_pos)
      {
      case CTK_BASELINE_POSITION_TOP:
        baseline = minimum_above;
        break;
      case CTK_BASELINE_POSITION_CENTER:
        baseline = minimum_above + (height - (minimum_above + minimum_below)) / 2;
        break;
      case CTK_BASELINE_POSITION_BOTTOM:
        baseline = height - minimum_below;
        break;
      }
  }

/* Allocate child positions. */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; ++packing)
  {
    if (priv->orientation == CTK_ORIENTATION_HORIZONTAL)
      {
        child_allocation.y = allocation->y;
        child_allocation.height = MAX (1, allocation->height)(((1) > (allocation->height)) ? (1) : (allocation->height
));
        if ((packing == CTK_PACK_START && direction == CTK_TEXT_DIR_LTR) ||
            (packing == CTK_PACK_END && direction == CTK_TEXT_DIR_RTL))
          x = allocation->x;
        else
          x = allocation->x + allocation->width;
      }
    else
      {
        child_allocation.x = allocation->x;
        child_allocation.width = MAX (1, allocation->width)(((1) > (allocation->width)) ? (1) : (allocation->width
));
        if (packing == CTK_PACK_START)
          y = allocation->y;
        else
          y = allocation->y + allocation->height;
      }

    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;

        /* Skip the center widget */
        if (child == priv->center)
          continue;

        /* If widget is packed differently, skip it. */
        if (child->pack != packing)
          continue;

        child_size = sizes[packing][i].natural_size;

        /* Assign the child's position. */
        if (priv->orientation == CTK_ORIENTATION_HORIZONTAL)
          {
            if (child->fill)
              {
                child_allocation.width = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
                child_allocation.x = x + child->padding;
              }
            else
              {
                child_allocation.width = sizes[packing][i].minimum_size;
                child_allocation.x = x + (child_size - child_allocation.width) / 2;
              }

            if ((packing == CTK_PACK_START && direction == CTK_TEXT_DIR_LTR) ||
                (packing == CTK_PACK_END && direction == CTK_TEXT_DIR_RTL))
              {
                x += child_size + priv->spacing;
              }
            else
              {
                x -= child_size + priv->spacing;
                child_allocation.x -= child_size;
              }
          }
        else /* (private->orientation == CTK_ORIENTATION_VERTICAL) */
          {
            if (child->fill)
              {
                child_allocation.height = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
                child_allocation.y = y + child->padding;
              }
            else
              {
                child_allocation.height = sizes[packing][i].minimum_size;
                child_allocation.y = y + (child_size - child_allocation.height) / 2;
              }

            if (packing == CTK_PACK_START)
              {
                y += child_size + priv->spacing;
              }
            else
              {
                y -= child_size + priv->spacing;
                child_allocation.y -= child_size;
              }
          }
        ctk_widget_size_allocate_with_baseline (child->widget, &child_allocation, baseline);

        i++;
      }

    if (priv->orientation == CTK_ORIENTATION_HORIZONTAL)
      side[packing] = x;
    else
      side[packing] = y;
  }

/* Allocate the center widget */
if (priv->orientation == CTK_ORIENTATION_HORIZONTAL)
  center_pos = allocation->x + (box_size - center_size) / 2;
else
  center_pos = allocation->y + (box_size - center_size) / 2;

if (priv->orientation == CTK_ORIENTATION_HORIZONTAL &&
    direction == CTK_TEXT_DIR_RTL)
  packing = CTK_PACK_END;
else
  packing = CTK_PACK_START;

if (center_pos < side[packing])
  center_pos = side[packing];
else if (center_pos + center_size > side[1 - packing])
  center_pos = side[1 - packing] - center_size;

if (priv->orientation == CTK_ORIENTATION_HORIZONTAL)
  {
    child_allocation.x = center_pos;
    child_allocation.width = center_size;
  }
else
  {
    child_allocation.y = center_pos;
    child_allocation.height = center_size;
  }
ctk_widget_size_allocate_with_baseline (priv->center->widget, &child_allocation, baseline);

_ctk_widget_set_simple_clip (widget, NULL((void*)0));
1195}

1197static void
1198ctk_box_allocate_contents (CtkCssGadget        *gadget,
                         const CtkAllocation *allocation,
                         int                  baseline G_GNUC_UNUSED__attribute__ ((__unused__)),
                         CtkAllocation       *out_clip,
                         gpointer             unused G_GNUC_UNUSED__attribute__ ((__unused__)))
1203{
CtkWidget *widget = ctk_css_gadget_get_owner (gadget);
CtkBox *box = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))));

if (box->priv->center &&
    _ctk_widget_get_visible (box->priv->center->widget))
  ctk_box_size_allocate_with_center (widget, allocation);
else
  ctk_box_size_allocate_no_center (widget, allocation);

ctk_container_get_children_clip (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), out_clip);
1214}

1216static void
1217ctk_box_size_allocate (CtkWidget     *widget,
                     CtkAllocation *allocation)
1219{
CtkBoxPrivate *priv = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))))->priv;
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);
1231}

1233static GType
1234ctk_box_child_type (CtkContainer   *container G_GNUC_UNUSED__attribute__ ((__unused__)))
1235{
return CTK_TYPE_WIDGET(ctk_widget_get_type ());
1237}

1239static void
1240ctk_box_set_child_property (CtkContainer *container,
                          CtkWidget    *child,
                          guint         property_id,
                          const GValue *value,
                          GParamSpec   *pspec)
1245{
gboolean expand = 0;
gboolean fill = 0;
guint padding = 0;
CtkPackType pack_type = 0;

if (property_id != CHILD_PROP_POSITION)
  ctk_box_query_child_packing (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
		 child,
		 &expand,
		 &fill,
		 &padding,
		 &pack_type);
switch (property_id)
  {
  case CHILD_PROP_EXPAND:
    ctk_box_set_child_packing (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
		 child,
		 g_value_get_boolean (value),
		 fill,
		 padding,
		 pack_type);
    break;
  case CHILD_PROP_FILL:
    ctk_box_set_child_packing (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
		 child,
		 expand,
		 g_value_get_boolean (value),
		 padding,
		 pack_type);
    break;
  case CHILD_PROP_PADDING:
    ctk_box_set_child_packing (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
		 child,
		 expand,
		 fill,
		 g_value_get_uint (value),
		 pack_type);
    break;
  case CHILD_PROP_PACK_TYPE:
    ctk_box_set_child_packing (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
		 child,
		 expand,
		 fill,
		 padding,
		 g_value_get_enum (value));
    break;
  case CHILD_PROP_POSITION:
    ctk_box_reorder_child (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
	     child,
	     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'"
, "ctkbox.c", 1298, ("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;
  }
1301}

1303static void
1304ctk_box_get_child_property (CtkContainer *container,
	    CtkWidget    *child,
	    guint         property_id,
	    GValue       *value,
	    GParamSpec   *pspec)
1309{
gboolean expand = FALSE(0);
gboolean fill = FALSE(0);
guint padding = 0;
CtkPackType pack_type = 0;
GList *list;

if (property_id != CHILD_PROP_POSITION)
  ctk_box_query_child_packing (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))),
		 child,
		 &expand,
		 &fill,
		 &padding,
		 &pack_type);
switch (property_id)
  {
    guint i;
  case CHILD_PROP_EXPAND:
    g_value_set_boolean (value, expand);
    break;
  case CHILD_PROP_FILL:
    g_value_set_boolean (value, fill);
    break;
  case CHILD_PROP_PADDING:
    g_value_set_uint (value, padding);
    break;
  case CHILD_PROP_PACK_TYPE:
    g_value_set_enum (value, pack_type);
    break;
  case CHILD_PROP_POSITION:
    i = 0;
    for (list = CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ()))))))->priv->children; list; list = list->next)
{
 CtkBoxChild *child_entry;

 child_entry = list->data;
 if (child_entry->widget == child)
   break;
 i++;
}
    g_value_set_int (value, list ? i : -1);
    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'"
, "ctkbox.c", 1352, ("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;
  }
1355}

1357typedef struct _CountingData CountingData;
1358struct _CountingData {
CtkWidget *widget;
gboolean found;
guint before;
guint after;
1363};

1365static void
1366count_widget_position (CtkWidget *widget,
                     gpointer   data)
1368{
CountingData *count = data;

if (!_ctk_widget_get_visible (widget))
  return;

if (count->widget == widget)
  count->found = TRUE(!(0));
else if (count->found)
  count->after++;
else
  count->before++;
1380}

1382static gint
1383ctk_box_get_visible_position (CtkBox    *box,
                            CtkWidget *child)
1385{
CountingData count = { child, FALSE(0), 0, 0 };

/* foreach iterates in visible order */
ctk_container_foreach (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))),
                       count_widget_position,
                       &count);

/* the child wasn't found, it's likely an internal child of some
 * subclass, return -1 to indicate that there is no sibling relation
 * to the regular box children
 */
if (!count.found)
  return -1;

if (box->priv->orientation == CTK_ORIENTATION_HORIZONTAL &&
    ctk_widget_get_direction (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))) == CTK_TEXT_DIR_RTL)
  return count.after;
else
  return count.before;
1405}

1407static CtkWidgetPath *
1408ctk_box_get_path_for_child (CtkContainer *container,
                          CtkWidget    *child)
1410{
CtkWidgetPath *path, *sibling_path;
CtkBox *box;
CtkBoxPrivate *private;
GList *list, *children;

box = CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ()))))));
private = box->priv;

path = _ctk_widget_create_path (CTK_WIDGET (container)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_widget_get_type ())))))));

if (_ctk_widget_get_visible (child))
  {
    gint position;

    sibling_path = ctk_widget_path_new ();

    /* get_children works in visible order */
    children = ctk_container_get_children (container);
    if (private->orientation == CTK_ORIENTATION_HORIZONTAL &&
        ctk_widget_get_direction (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))) == CTK_TEXT_DIR_RTL)
      children = g_list_reverse (children);

    for (list = children; list; list = list->next)
      {
        if (!_ctk_widget_get_visible (list->data))
          continue;

        ctk_widget_path_append_for_widget (sibling_path, list->data);
      }

    g_list_free (children);

    position = ctk_box_get_visible_position (box, child);

    if (position >= 0)
      ctk_widget_path_append_with_siblings (path, sibling_path, position);
    else
      ctk_widget_path_append_for_widget (path, child);

    ctk_widget_path_unref (sibling_path);
  }
else
  ctk_widget_path_append_for_widget (path, child);

return path;
1456}

1458static void
1459ctk_box_buildable_add_child (CtkBuildable *buildable,
                           CtkBuilder   *builder G_GNUC_UNUSED__attribute__ ((__unused__)),
                           GObject      *child,
                           const gchar  *type)
1463{
if (type && strcmp (type, "center") == 0)
  ctk_box_set_center_widget (CTK_BOX (buildable)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((buildable)), ((ctk_box_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_BOX (buildable), type)g_warning ("'%s' is not a valid child type of '%s'", type, g_type_name
 ((((((GTypeClass*) (((GTypeInstance*) (((((CtkBox*) (void *)
 g_type_check_instance_cast ((GTypeInstance*) ((buildable)), (
(ctk_box_get_type ()))))))))->g_class))->g_type)))));
1470}

1472static void
1473ctk_box_buildable_init (CtkBuildableIface *iface)
1474{
iface->add_child = ctk_box_buildable_add_child;
1476}

1478static void
1479ctk_box_update_child_css_position (CtkBox      *box,
                                 CtkBoxChild *child_info)
1481{
CtkBoxPrivate *priv = box->priv;
CtkBoxChild *prev;
gboolean reverse;
GList *l;

prev = NULL((void*)0);
for (l = priv->children; l->data != child_info; l = l->next)
  {
    CtkBoxChild *cur = l->data;

    if (cur->pack == child_info->pack)
      prev = cur;
  }

reverse = child_info->pack == CTK_PACK_END;
if (box->priv->orientation == CTK_ORIENTATION_HORIZONTAL &&
    ctk_widget_get_direction (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))) == CTK_TEXT_DIR_RTL)
  reverse = !reverse;

if (reverse)
  ctk_css_node_insert_before (ctk_widget_get_css_node (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))),
                              ctk_widget_get_css_node (child_info->widget),
                              prev ? ctk_widget_get_css_node (prev->widget) : NULL((void*)0));
else
  ctk_css_node_insert_after (ctk_widget_get_css_node (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))),
                             ctk_widget_get_css_node (child_info->widget),
                             prev ? ctk_widget_get_css_node (prev->widget) : NULL((void*)0));
1509}

1511static void
1512ctk_box_direction_changed (CtkWidget        *widget,
                         CtkTextDirection  previous_direction G_GNUC_UNUSED__attribute__ ((__unused__)))
1514{
CtkBox *box = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))));

if (box->priv->orientation == CTK_ORIENTATION_HORIZONTAL)
  ctk_css_node_reverse_children (ctk_widget_get_css_node (widget));
1519}

1521static CtkBoxChild *
1522ctk_box_pack (CtkBox      *box,
            CtkWidget   *child,
            gboolean     expand,
            gboolean     fill,
            guint        padding,
            CtkPackType  pack_type)
1528{
CtkContainer *container = CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ()))))));
CtkBoxPrivate *private = box->priv;
CtkBoxChild *child_info;

g_return_val_if_fail (CTK_IS_BOX (box), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return (((void*)0)); } } while (0);
g_return_val_if_fail (CTK_IS_WIDGET (child), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((child)); 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 (child)"); return (((void*)0)); } } while (
0);
g_return_val_if_fail (_ctk_widget_get_parent (child) == NULL, NULL)do { if ((_ctk_widget_get_parent (child) == ((void*)0))) { } else
 { g_return_if_fail_warning ("Ctk", ((const char*) (__func__)
), "_ctk_widget_get_parent (child) == NULL"); return (((void*
)0)); } } while (0);

child_info = g_new (CtkBoxChild, 1)((CtkBoxChild *) g_malloc_n ((1), sizeof (CtkBoxChild)));
child_info->widget = child;
child_info->padding = padding;
child_info->expand = expand ? TRUE(!(0)) : FALSE(0);
child_info->fill = fill ? TRUE(!(0)) : FALSE(0);
child_info->pack = pack_type;

private->children = g_list_append (private->children, child_info);
ctk_box_update_child_css_position (box, child_info);

ctk_widget_freeze_child_notify (child);

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

if (expand)
  ctk_container_child_notify_by_pspec (container, child, child_props[CHILD_PROP_EXPAND]);
if (!fill)
  ctk_container_child_notify_by_pspec (container, child, child_props[CHILD_PROP_FILL]);
if (padding != 0)
  ctk_container_child_notify_by_pspec (container, child, child_props[CHILD_PROP_PADDING]);
if (pack_type != CTK_PACK_START)
  ctk_container_child_notify_by_pspec (container, child, child_props[CHILD_PROP_PACK_TYPE]);
ctk_container_child_notify_by_pspec (container, child, child_props[CHILD_PROP_POSITION]);

ctk_widget_thaw_child_notify (child);

return child_info;
1564}

1566static void
1567ctk_box_get_size (CtkWidget      *widget,
  CtkOrientation  orientation,
  gint           *minimum_size,
  gint           *natural_size,
  gint           *minimum_baseline,
  gint           *natural_baseline)
1573{
CtkBox *box;
CtkBoxPrivate *private;
GList *children;
gint nvis_children;
gint minimum, natural;
gint minimum_above, natural_above;
gint minimum_below, natural_below;
gboolean have_baseline;
gint min_baseline, nat_baseline;
gint center_min, center_nat;

box = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))));
private = box->priv;

have_baseline = FALSE(0);
minimum = natural = 0;
minimum_above = natural_above = 0;
minimum_below = natural_below = 0;
min_baseline = nat_baseline = -1;

nvis_children = 0;

center_min = center_nat = 0;

for (children = private->children; children; children = children->next)
  {
    CtkBoxChild *child = children->data;

    if (_ctk_widget_get_visible (child->widget))
      {
        gint child_minimum, child_natural;
        gint child_minimum_baseline = -1, child_natural_baseline = -1;

 if (orientation == CTK_ORIENTATION_HORIZONTAL)
   ctk_widget_get_preferred_width (child->widget,
                                          &child_minimum, &child_natural);
 else
   ctk_widget_get_preferred_height_and_baseline_for_width (child->widget, -1,
						    &child_minimum, &child_natural,
						    &child_minimum_baseline, &child_natural_baseline);

        if (private->orientation == orientation)
   {
            if (private->homogeneous)
              {
                if (child == private->center)
                  {
                    center_min = child_minimum + child->padding * 2;
                    center_nat = child_natural + child->padding * 2;
                  }
                else
                  {
                    gint largest;

                    largest = child_minimum + child->padding * 2;
                    minimum = MAX (minimum, largest)(((minimum) > (largest)) ? (minimum) : (largest));

                    largest = child_natural + child->padding * 2;
                    natural = MAX (natural, largest)(((natural) > (largest)) ? (natural) : (largest));
                  }
              }
            else
              {
                minimum += child_minimum + child->padding * 2;
                natural += child_natural + child->padding * 2;
              }
   }
 else
   {
     if (child_minimum_baseline >= 0)
{
  have_baseline = TRUE(!(0));
  minimum_below = MAX (minimum_below, child_minimum - child_minimum_baseline)(((minimum_below) > (child_minimum - child_minimum_baseline
)) ? (minimum_below) : (child_minimum - child_minimum_baseline
));
  natural_below = MAX (natural_below, child_natural - child_natural_baseline)(((natural_below) > (child_natural - child_natural_baseline
)) ? (natural_below) : (child_natural - child_natural_baseline
));
  minimum_above = MAX (minimum_above, child_minimum_baseline)(((minimum_above) > (child_minimum_baseline)) ? (minimum_above
) : (child_minimum_baseline));
  natural_above = MAX (natural_above, child_natural_baseline)(((natural_above) > (child_natural_baseline)) ? (natural_above
) : (child_natural_baseline));
}
     else
{
  /* The biggest mins and naturals in the opposing orientation */
  minimum = MAX (minimum, child_minimum)(((minimum) > (child_minimum)) ? (minimum) : (child_minimum
));
  natural = MAX (natural, child_natural)(((natural) > (child_natural)) ? (natural) : (child_natural
));
}
   }

        nvis_children += 1;
      }
  }

if (nvis_children > 0 && private->orientation == orientation)
  {
    if (private->homogeneous)
{
        if (center_min > 0)
          {
            minimum = minimum * (nvis_children - 1) + center_min;
            natural = natural * (nvis_children - 1) + center_nat;
          }
        else
          {
     minimum *= nvis_children;
     natural *= nvis_children;
          }
}
    minimum += (nvis_children - 1) * private->spacing;
    natural += (nvis_children - 1) * private->spacing;
  }

minimum = MAX (minimum, minimum_below + minimum_above)(((minimum) > (minimum_below + minimum_above)) ? (minimum)
 : (minimum_below + minimum_above));
natural = MAX (natural, natural_below + natural_above)(((natural) > (natural_below + natural_above)) ? (natural)
 : (natural_below + natural_above));

if (have_baseline)
  {
    switch (private->baseline_pos)
{
case CTK_BASELINE_POSITION_TOP:
 min_baseline = minimum_above;
 nat_baseline = natural_above;
 break;
case CTK_BASELINE_POSITION_CENTER:
 min_baseline = minimum_above + (minimum - (minimum_above + minimum_below)) / 2;
 nat_baseline = natural_above + (natural - (natural_above + natural_below)) / 2;
 break;
case CTK_BASELINE_POSITION_BOTTOM:
 min_baseline = minimum - minimum_below;
 nat_baseline = natural - natural_below;
 break;
}
  }

if (minimum_size)
  *minimum_size = minimum;

if (natural_size)
  *natural_size = natural;

if (minimum_baseline)
  *minimum_baseline = min_baseline;

if (natural_baseline)
  *natural_baseline = nat_baseline;
1715}

1717static void
1718ctk_box_get_preferred_width (CtkWidget *widget,
                           gint      *minimum,
                           gint      *natural)
1721{
ctk_css_gadget_get_preferred_size (CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_HORIZONTAL,
                                   -1,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
1727}

1729static void
1730ctk_box_get_preferred_height (CtkWidget *widget,
                            gint      *minimum,
                            gint      *natural)
1733{
ctk_css_gadget_get_preferred_size (CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   -1,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
1739}

1741static void
1742ctk_box_compute_size_for_opposing_orientation (CtkBox *box,
			       gint    avail_size,
			       gint   *minimum_size,
			       gint   *natural_size,
			       gint   *minimum_baseline,
			       gint   *natural_baseline)
1748{
CtkBoxPrivate       *private = box->priv;
CtkBoxChild      *child;
GList            *children;
gint              nvis_children;
gint              nexpand_children;
gint              computed_minimum = 0, computed_natural = 0;
gint              computed_minimum_above = 0, computed_natural_above = 0;
gint              computed_minimum_below = 0, computed_natural_below = 0;
gint              computed_minimum_baseline = -1, computed_natural_baseline = -1;
CtkRequestedSize *sizes;
CtkPackType       packing;
gint              size, extra, i;
gint              child_size, child_minimum, child_natural;
gint              child_minimum_baseline, child_natural_baseline;
gint              n_extra_widgets = 0;
gboolean          have_baseline;

count_expand_children (box, &nvis_children, &nexpand_children);

if (nvis_children <= 0)
  return;

sizes = g_newa (CtkRequestedSize, nvis_children)((CtkRequestedSize*) __builtin_alloca (sizeof (CtkRequestedSize
) * (gsize) (nvis_children)));
memset (sizes, 0, nvis_children * sizeof (CtkRequestedSize));
size = avail_size - (nvis_children - 1) * private->spacing;

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

    if (_ctk_widget_get_visible (child->widget))
{
 if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
   ctk_widget_get_preferred_width (child->widget,
                                          &sizes[i].minimum_size,
                                          &sizes[i].natural_size);
 else
   ctk_widget_get_preferred_height (child->widget,
                                           &sizes[i].minimum_size,
                                           &sizes[i].natural_size);

 /* Assert the api is working properly */
 if (sizes[i].minimum_size < 0)
   g_error ("CtkBox child %s minimum %s: %d < 0",
     ctk_widget_get_name (CTK_WIDGET (child->widget)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child->widget)), ((ctk_widget_get_type ()))))))),
     (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? "width" : "height",
     sizes[i].minimum_size);

 if (sizes[i].natural_size < sizes[i].minimum_size)
   g_error ("CtkBox child %s natural %s: %d < minimum %d",
     ctk_widget_get_name (CTK_WIDGET (child->widget)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((child->widget)), ((ctk_widget_get_type ()))))))),
     (private->orientation == CTK_ORIENTATION_HORIZONTAL) ? "width" : "height",
     sizes[i].natural_size,
     sizes[i].minimum_size);

 size -= sizes[i].minimum_size;
 size -= child->padding * 2;

 sizes[i].data = child;

 i += 1;
}
  }

if (private->homogeneous)
  {
    /* If were homogenous we still need to run the above loop to get the
     * minimum sizes for children that are not going to fill
     */
    size = avail_size - (nvis_children - 1) * private->spacing;
    extra = size / nvis_children;
    n_extra_widgets = size % nvis_children;
  }
else
  {
    /* Bring children up to size first */
    size = ctk_distribute_natural_allocation (MAX (0, size)(((0) > (size)) ? (0) : (size)), nvis_children, sizes);

    /* Calculate space which hasn't distributed yet,
     * and is available for expanding children.
     */
    if (nexpand_children > 0)
{
 extra = size / nexpand_children;
 n_extra_widgets = size % nexpand_children;
}
    else
extra = 0;
  }

have_baseline = FALSE(0);
/* Allocate child positions. */
for (packing = CTK_PACK_START; packing <= CTK_PACK_END; ++packing)
  {
    for (i = 0, children = private->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 != packing)
   {
     i++;
     continue;
   }

 if (child->pack == packing)
   {
     /* Assign the child's size. */
     if (private->homogeneous)
{
  child_size = extra;

  if (n_extra_widgets > 0)
    {
      child_size++;
      n_extra_widgets--;
    }
}
     else
{
  child_size = sizes[i].minimum_size + child->padding * 2;

  if (child->expand || ctk_widget_compute_expand (child->widget, private->orientation))
    {
      child_size += extra;

      if (n_extra_widgets > 0)
	{
	  child_size++;
	  n_extra_widgets--;
	}
    }
}

     if (child->fill)
{
  child_size = MAX (1, child_size - child->padding * 2)(((1) > (child_size - child->padding * 2)) ? (1) : (child_size
 - child->padding * 2));
}
     else
{
  child_size = sizes[i].minimum_size;
}


     child_minimum_baseline = child_natural_baseline = -1;
     /* Assign the child's position. */
     if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
ctk_widget_get_preferred_height_and_baseline_for_width (child->widget, child_size,
							&child_minimum, &child_natural,
							&child_minimum_baseline, &child_natural_baseline);
     else /* (private->orientation == CTK_ORIENTATION_VERTICAL) */
ctk_widget_get_preferred_width_for_height (child->widget,
                                                         child_size, &child_minimum, &child_natural);

     if (child_minimum_baseline >= 0)
{
  have_baseline = TRUE(!(0));
  computed_minimum_below = MAX (computed_minimum_below, child_minimum - child_minimum_baseline)(((computed_minimum_below) > (child_minimum - child_minimum_baseline
)) ? (computed_minimum_below) : (child_minimum - child_minimum_baseline
));
  computed_natural_below = MAX (computed_natural_below, child_natural - child_natural_baseline)(((computed_natural_below) > (child_natural - child_natural_baseline
)) ? (computed_natural_below) : (child_natural - child_natural_baseline
));
  computed_minimum_above = MAX (computed_minimum_above, child_minimum_baseline)(((computed_minimum_above) > (child_minimum_baseline)) ? (
computed_minimum_above) : (child_minimum_baseline));
  computed_natural_above = MAX (computed_natural_above, child_natural_baseline)(((computed_natural_above) > (child_natural_baseline)) ? (
computed_natural_above) : (child_natural_baseline));
}
     else
{
  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;
}
  }

if (have_baseline)
  {
    computed_minimum = MAX (computed_minimum, computed_minimum_below + computed_minimum_above)(((computed_minimum) > (computed_minimum_below + computed_minimum_above
)) ? (computed_minimum) : (computed_minimum_below + computed_minimum_above
));
    computed_natural = MAX (computed_natural, computed_natural_below + computed_natural_above)(((computed_natural) > (computed_natural_below + computed_natural_above
)) ? (computed_natural) : (computed_natural_below + computed_natural_above
));
    switch (private->baseline_pos)
{
case CTK_BASELINE_POSITION_TOP:
 computed_minimum_baseline = computed_minimum_above;
 computed_natural_baseline = computed_natural_above;
 break;
case CTK_BASELINE_POSITION_CENTER:
 computed_minimum_baseline = computed_minimum_above + MAX((computed_minimum - (computed_minimum_above + computed_minimum_below)) / 2, 0)((((computed_minimum - (computed_minimum_above + computed_minimum_below
)) / 2) > (0)) ? ((computed_minimum - (computed_minimum_above
 + computed_minimum_below)) / 2) : (0));
 computed_natural_baseline = computed_natural_above + MAX((computed_natural - (computed_natural_above + computed_natural_below)) / 2, 0)((((computed_natural - (computed_natural_above + computed_natural_below
)) / 2) > (0)) ? ((computed_natural - (computed_natural_above
 + computed_natural_below)) / 2) : (0));
 break;
case CTK_BASELINE_POSITION_BOTTOM:
 computed_minimum_baseline = computed_minimum - computed_minimum_below;
 computed_natural_baseline = computed_natural - computed_natural_below;
 break;
}
  }

if (minimum_baseline)
  *minimum_baseline = computed_minimum_baseline;
if (natural_baseline)
  *natural_baseline = computed_natural_baseline;

if (minimum_size)
  *minimum_size = computed_minimum;
if (natural_size)
  *natural_size = MAX (computed_natural, computed_natural_below + computed_natural_above)(((computed_natural) > (computed_natural_below + computed_natural_above
)) ? (computed_natural) : (computed_natural_below + computed_natural_above
));
1960}

1962static void
1963ctk_box_compute_size_for_orientation (CtkBox *box,
		      gint    avail_size,
		      gint   *minimum_size,
		      gint   *natural_size)
1967{
CtkBoxPrivate    *private = box->priv;
GList         *children;
gint           nvis_children = 0;
gint           required_size = 0, required_natural = 0, child_size, child_natural;
gint           largest_child = 0, largest_natural = 0;

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

    if (_ctk_widget_get_visible (child->widget))
      {

        if (private->orientation == CTK_ORIENTATION_HORIZONTAL)
   ctk_widget_get_preferred_width_for_height (child->widget,
                                                     avail_size, &child_size, &child_natural);
 else
   ctk_widget_get_preferred_height_for_width (child->widget,
				       avail_size, &child_size, &child_natural);


 child_size    += child->padding * 2;
 child_natural += child->padding * 2;

 if (child_size > largest_child)
   largest_child = child_size;

 if (child_natural > largest_natural)
   largest_natural = child_natural;

 required_size    += child_size;
 required_natural += child_natural;

        nvis_children += 1;
      }
  }

if (nvis_children > 0)
  {
    if (private->homogeneous)
{
 required_size    = largest_child   * nvis_children;
 required_natural = largest_natural * nvis_children;
}

    required_size     += (nvis_children - 1) * private->spacing;
    required_natural  += (nvis_children - 1) * private->spacing;
  }

if (minimum_size)
  *minimum_size = required_size;

if (natural_size)
  *natural_size = required_natural;
2023}

2025static void
2026ctk_box_get_preferred_width_for_height (CtkWidget *widget,
                                      gint       height,
                                      gint      *minimum,
                                      gint      *natural)
2030{
ctk_css_gadget_get_preferred_size (CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_HORIZONTAL,
                                   height,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
2036}

2038static void
2039ctk_box_get_preferred_height_and_baseline_for_width (CtkWidget *widget,
				     gint       width,
				     gint      *minimum,
				     gint      *natural,
				     gint      *minimum_baseline,
				     gint      *natural_baseline)
2045{
ctk_css_gadget_get_preferred_size (CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   width,
                                   minimum, natural,
                                   minimum_baseline, natural_baseline);
2051}

2053static void
2054ctk_box_get_content_size (CtkCssGadget   *gadget,
                        CtkOrientation  orientation,
                        gint            for_size,
                        gint           *minimum,
                        gint           *natural,
                        gint           *minimum_baseline,
                        gint           *natural_baseline,
                        gpointer        unused G_GNUC_UNUSED__attribute__ ((__unused__)))
2062{
CtkWidget     *widget  = ctk_css_gadget_get_owner (gadget);
CtkBox        *box     = CTK_BOX (widget)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *private = box->priv;

if (for_size < 0)
  ctk_box_get_size (widget, orientation, minimum, natural, minimum_baseline, natural_baseline);
else
  {
    if (private->orientation != orientation)
ctk_box_compute_size_for_opposing_orientation (box, for_size, minimum, natural, minimum_baseline, natural_baseline);
    else
{
 if (minimum_baseline)
   *minimum_baseline = -1;
 if (natural_baseline)
   *natural_baseline = -1;
 ctk_box_compute_size_for_orientation (box, for_size, minimum, natural);
}
  }
2082}

2084static void
2085ctk_box_get_preferred_height_for_width (CtkWidget *widget,
                                      gint       width,
                                      gint      *minimum_height,
                                      gint      *natural_height)
2089{
ctk_box_get_preferred_height_and_baseline_for_width (widget, width, minimum_height, natural_height, NULL((void*)0), NULL((void*)0));
2091}

2093static void
2094ctk_box_init (CtkBox *box)
2095{
CtkBoxPrivate *private;

box->priv = ctk_box_get_instance_private (box);
private = box->priv;

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

private->orientation = CTK_ORIENTATION_HORIZONTAL;
private->children = NULL((void*)0);

private->default_expand = FALSE(0);
private->homogeneous = FALSE(0);
private->spacing = 0;
private->spacing_set = FALSE(0);
private->baseline_pos = CTK_BASELINE_POSITION_CENTER;

private->gadget = ctk_css_custom_gadget_new_for_node (ctk_widget_get_css_node (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))),
                                                      CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ())))))),
                                                      ctk_box_get_content_size,
                                                      ctk_box_allocate_contents,
                                                      ctk_box_draw_contents,
                                                      NULL((void*)0),
                                                      NULL((void*)0));

_ctk_orientable_set_style_classes (CTK_ORIENTABLE (box)((((CtkOrientable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_orientable_get_type ())))))));
2121}

2123CtkCssGadget *
2124ctk_box_get_gadget (CtkBox *box)
2125{
return box->priv->gadget;
2127}

2129/**
* ctk_box_new:
* @orientation: the box’s orientation.
* @spacing: the number of pixels to place by default between children.
*
* Creates a new #CtkBox.
*
* Returns: a new #CtkBox.
*
* Since: 3.0
**/
2140CtkWidget*
2141ctk_box_new (CtkOrientation orientation,
           gint           spacing)
2143{
return g_object_new (CTK_TYPE_BOX(ctk_box_get_type ()),
                     "orientation", orientation,
                     "spacing",     spacing,
                     NULL((void*)0));
2148}

2150/**
* ctk_box_pack_start:
* @box: a #CtkBox
* @child: the #CtkWidget to be added to @box
* @expand: %TRUE if the new child is to be given extra space allocated
*     to @box. The extra space will be divided evenly between all children
*     that use this option
* @fill: %TRUE if space given to @child by the @expand option is
*     actually allocated to @child, rather than just padding it.  This
*     parameter has no effect if @expand is set to %FALSE.  A child is
*     always allocated the full height of a horizontal #CtkBox and the full width
*     of a vertical #CtkBox. This option affects the other dimension
* @padding: extra space in pixels to put between this child and its
*   neighbors, over and above the global amount specified by
*   #CtkBox:spacing property.  If @child is a widget at one of the
*   reference ends of @box, then @padding pixels are also put between
*   @child and the reference edge of @box
*
* Adds @child to @box, packed with reference to the start of @box.
* The @child is packed after any other child packed with reference
* to the start of @box.
*/
2172void
2173ctk_box_pack_start (CtkBox    *box,
    CtkWidget *child,
    gboolean   expand,
    gboolean   fill,
    guint      padding)
2178{
ctk_box_pack (box, child, expand, fill, padding, CTK_PACK_START);
2180}

2182/**
* ctk_box_pack_end:
* @box: a #CtkBox
* @child: the #CtkWidget to be added to @box
* @expand: %TRUE if the new child is to be given extra space allocated
*   to @box. The extra space will be divided evenly between all children
*   of @box that use this option
* @fill: %TRUE if space given to @child by the @expand option is
*   actually allocated to @child, rather than just padding it.  This
*   parameter has no effect if @expand is set to %FALSE.  A child is
*   always allocated the full height of a horizontal #CtkBox and the full width
*   of a vertical #CtkBox.  This option affects the other dimension
* @padding: extra space in pixels to put between this child and its
*   neighbors, over and above the global amount specified by
*   #CtkBox:spacing property.  If @child is a widget at one of the
*   reference ends of @box, then @padding pixels are also put between
*   @child and the reference edge of @box
*
* Adds @child to @box, packed with reference to the end of @box.
* The @child is packed after (away from end of) any other child
* packed with reference to the end of @box.
*/
2204void
2205ctk_box_pack_end (CtkBox    *box,
  CtkWidget *child,
  gboolean   expand,
  gboolean   fill,
  guint      padding)
2210{
ctk_box_pack (box, child, expand, fill, padding, CTK_PACK_END);
2212}

2214/**
* ctk_box_set_homogeneous:
* @box: a #CtkBox
* @homogeneous: a boolean value, %TRUE to create equal allotments,
*   %FALSE for variable allotments
*
* Sets the #CtkBox:homogeneous property of @box, controlling
* whether or not all children of @box are given equal space
* in the box.
*/
2224void
2225ctk_box_set_homogeneous (CtkBox  *box,
	 gboolean homogeneous)
2227{
CtkBoxPrivate *private;

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);

private = box->priv;

homogeneous = homogeneous != FALSE(0);

if (private->homogeneous != homogeneous)
  {
    private->homogeneous = homogeneous;
    g_object_notify_by_pspec (G_OBJECT (box)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), (((GType) ((20) << (2)))))))), props[PROP_HOMOGENEOUS]);
    ctk_widget_queue_resize (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ())))))));
  }
2242}

2244/**
* ctk_box_get_homogeneous:
* @box: a #CtkBox
*
* Returns whether the box is homogeneous (all children are the
* same size). See ctk_box_set_homogeneous().
*
* Returns: %TRUE if the box is homogeneous.
**/
2253gboolean
2254ctk_box_get_homogeneous (CtkBox *box)
2255{
g_return_val_if_fail (CTK_IS_BOX (box), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return ((0)); } } while (0);

return box->priv->homogeneous;
2259}

2261/**
* ctk_box_set_spacing:
* @box: a #CtkBox
* @spacing: the number of pixels to put between children
*
* Sets the #CtkBox:spacing property of @box, which is the
* number of pixels to place between children of @box.
*/
2269void
2270ctk_box_set_spacing (CtkBox *box,
     gint    spacing)
2272{
CtkBoxPrivate *private;

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);

private = box->priv;

if (private->spacing != spacing)
  {
    private->spacing = spacing;
    _ctk_box_set_spacing_set (box, TRUE(!(0)));

    g_object_notify_by_pspec (G_OBJECT (box)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), (((GType) ((20) << (2)))))))), props[PROP_SPACING]);

    ctk_widget_queue_resize (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ())))))));
  }
2288}

2290/**
* ctk_box_get_spacing:
* @box: a #CtkBox
*
* Gets the value set by ctk_box_set_spacing().
*
* Returns: spacing between children
**/
2298gint
2299ctk_box_get_spacing (CtkBox *box)
2300{
g_return_val_if_fail (CTK_IS_BOX (box), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return (0); } } while (0);

return box->priv->spacing;
2304}

2306/**
* ctk_box_set_baseline_position:
* @box: a #CtkBox
* @position: a #CtkBaselinePosition
*
* Sets the baseline position of a box. This affects
* only horizontal boxes with at least one baseline aligned
* child. If there is more vertical space available than requested,
* and the baseline is not allocated by the parent then
* @position is used to allocate the baseline wrt the
* extra space available.
*
* Since: 3.10
*/
2320void
2321ctk_box_set_baseline_position (CtkBox             *box,
	       CtkBaselinePosition position)
2323{
CtkBoxPrivate *private;

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);

private = box->priv;

if (private->baseline_pos != position)
  {
    private->baseline_pos = position;

    g_object_notify_by_pspec (G_OBJECT (box)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), (((GType) ((20) << (2)))))))), props[PROP_BASELINE_POSITION]);

    ctk_widget_queue_resize (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ())))))));
  }
2338}

2340/**
* ctk_box_get_baseline_position:
* @box: a #CtkBox
*
* Gets the value set by ctk_box_set_baseline_position().
*
* Returns: the baseline position
*
* Since: 3.10
**/
2350CtkBaselinePosition
2351ctk_box_get_baseline_position (CtkBox *box)
2352{
g_return_val_if_fail (CTK_IS_BOX (box), CTK_BASELINE_POSITION_CENTER)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return (CTK_BASELINE_POSITION_CENTER
); } } while (0);

return box->priv->baseline_pos;
2356}


2359void
2360_ctk_box_set_spacing_set (CtkBox  *box,
                        gboolean spacing_set)
2362{
CtkBoxPrivate *private;

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);

private = box->priv;

private->spacing_set = spacing_set ? TRUE(!(0)) : FALSE(0);
2370}

2372gboolean
2373_ctk_box_get_spacing_set (CtkBox *box)
2374{
CtkBoxPrivate *private;

g_return_val_if_fail (CTK_IS_BOX (box), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return ((0)); } } while (0);

private = box->priv;

return private->spacing_set;
2382}

2384/**
* ctk_box_reorder_child:
* @box: a #CtkBox
* @child: the #CtkWidget to move
* @position: the new position for @child in the list of children
*   of @box, starting from 0. If negative, indicates the end of
*   the list
*
* Moves @child to a new @position in the list of @box children.
* The list contains widgets packed #CTK_PACK_START
* as well as widgets packed #CTK_PACK_END, in the order that these
* widgets were added to @box.
*
* A widget’s position in the @box children list determines where
* the widget is packed into @box.  A child widget at some position
* in the list will be packed just after all other widgets of the
* same packing type that appear earlier in the list.
*/
2402void
2403ctk_box_reorder_child (CtkBox    *box,
       CtkWidget *child,
       gint       position)
2406{
CtkBoxPrivate *priv;
GList *old_link;
GList *new_link;
CtkBoxChild *child_info = NULL((void*)0);
gint old_position;

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);
g_return_if_fail (CTK_IS_WIDGET (child))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((child)); 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 (child)"); return; } } while (0);

priv = box->priv;

old_link = priv->children;
old_position = 0;
while (old_link)
  {
    child_info = old_link->data;
    if (child_info->widget == child)
break;

    old_link = old_link->next;
    old_position++;
  }

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

if (position == old_position)
  return;

priv->children = g_list_delete_link (priv->children, old_link);

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

priv->children = g_list_insert_before (priv->children, new_link, child_info);
ctk_box_update_child_css_position (box, child_info);

ctk_container_child_notify_by_pspec (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), child, child_props[CHILD_PROP_POSITION]);
if (_ctk_widget_get_visible (child) &&
    _ctk_widget_get_visible (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))))
  {
    ctk_widget_queue_resize (child);
  }
2451}

2453/**
* ctk_box_query_child_packing:
* @box: a #CtkBox
* @child: the #CtkWidget of the child to query
* @expand: (out): pointer to return location for expand child
*     property
* @fill: (out): pointer to return location for fill child
*     property
* @padding: (out): pointer to return location for padding
*     child property
* @pack_type: (out): pointer to return location for pack-type
*     child property
*
* Obtains information about how @child is packed into @box.
*/
2468void
2469ctk_box_query_child_packing (CtkBox      *box,
	     CtkWidget   *child,
	     gboolean    *expand,
	     gboolean    *fill,
	     guint       *padding,
	     CtkPackType *pack_type)
2475{
CtkBoxPrivate *private;
GList *list;
CtkBoxChild *child_info = NULL((void*)0);

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);
g_return_if_fail (CTK_IS_WIDGET (child))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((child)); 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 (child)"); return; } } while (0);

private = box->priv;

list = private->children;
while (list)
  {
    child_info = list->data;
    if (child_info->widget == child)
break;

    list = list->next;
  }

if (list)
  {
    if (expand)
*expand = child_info->expand;
    if (fill)
*fill = child_info->fill;
    if (padding)
*padding = child_info->padding;
    if (pack_type)
*pack_type = child_info->pack;
  }
2506}

2508/**
* ctk_box_set_child_packing:
* @box: a #CtkBox
* @child: the #CtkWidget of the child to set
* @expand: the new value of the expand child property
* @fill: the new value of the fill child property
* @padding: the new value of the padding child property
* @pack_type: the new value of the pack-type child property
*
* Sets the way @child is packed into @box.
*/
2519void
2520ctk_box_set_child_packing (CtkBox      *box,
	   CtkWidget   *child,
	   gboolean     expand,
	   gboolean     fill,
	   guint        padding,
	   CtkPackType  pack_type)
2526{
CtkBoxPrivate *private;
GList *list;
CtkBoxChild *child_info = NULL((void*)0);

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);
g_return_if_fail (CTK_IS_WIDGET (child))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((child)); 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 (child)"); return; } } while (0);

private = box->priv;

list = private->children;
while (list)
  {
    child_info = list->data;
    if (child_info->widget == child)
break;

    list = list->next;
  }

ctk_widget_freeze_child_notify (child);
if (list)
  {
    expand = expand != FALSE(0);

    if (child_info->expand != expand)
      {
        child_info->expand = expand;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), child, child_props[CHILD_PROP_EXPAND]);
      }

    fill = fill != FALSE(0);

    if (child_info->fill != fill)
      {
        child_info->fill = fill;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), child, child_props[CHILD_PROP_FILL]);
      }

    if (child_info->padding != padding)
      {
        child_info->padding = padding;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), child, child_props[CHILD_PROP_PADDING]);
      }

    if (pack_type != CTK_PACK_END)
      pack_type = CTK_PACK_START;
    if (child_info->pack != pack_type)
      {
 child_info->pack = pack_type;
        ctk_box_update_child_css_position (box, child_info);
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), child, child_props[CHILD_PROP_PACK_TYPE]);
      }

    if (_ctk_widget_get_visible (child) &&
        _ctk_widget_get_visible (CTK_WIDGET (box)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_widget_get_type ()))))))))
ctk_widget_queue_resize (child);
  }
ctk_widget_thaw_child_notify (child);
2585}

2587void
2588_ctk_box_set_old_defaults (CtkBox *box)
2589{
CtkBoxPrivate *private;

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);

private = box->priv;

private->default_expand = TRUE(!(0));
2597}

2599static void
2600ctk_box_add (CtkContainer *container,
    CtkWidget    *widget)
2602{
CtkBoxPrivate *priv = CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ()))))))->priv;

ctk_box_pack_start (CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ())))))), widget,
                    priv->default_expand,
                    TRUE(!(0)),
                    0);
2609}

2611static void
2612ctk_box_remove (CtkContainer *container,
CtkWidget    *widget)
2614{
CtkBox *box = CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *priv = box->priv;
CtkBoxChild *child;
GList *children;

children = priv->children;
while (children)
  {
    child = children->data;

    if (child->widget == widget)
{
 gboolean was_visible;

        if (priv->center == child)
          priv->center = NULL((void*)0);

 was_visible = _ctk_widget_get_visible (widget);
 ctk_widget_unparent (widget);

 priv->children = g_list_remove_link (priv->children, children);
 g_list_free (children);
 g_free (child);

 /* queue resize regardless of ctk_widget_get_visible (container),
  * since that's what is needed by toplevels.
  */
 if (was_visible)
          {
     ctk_widget_queue_resize (CTK_WIDGET (container)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_widget_get_type ())))))));
          }

 break;
}

    children = children->next;
  }
2652}

2654static void
2655ctk_box_forall (CtkContainer *container,
gboolean      include_internals G_GNUC_UNUSED__attribute__ ((__unused__)),
CtkCallback   callback,
gpointer      callback_data)
2659{
CtkBox *box = CTK_BOX (container)((((CtkBox*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_box_get_type ()))))));
CtkBoxPrivate *priv = box->priv;
CtkBoxChild *child;
GList *children;

children = priv->children;
while (children)
  {
    child = children->data;
    children = children->next;

    if (child == priv->center)
      continue;

    if (child->pack == CTK_PACK_START)
(* callback) (child->widget, callback_data);
  }

if (priv->center)
  (* callback) (priv->center->widget, callback_data);

children = g_list_last (priv->children);
while (children)
  {
    child = children->data;
    children = children->prev;

    if (child == priv->center)
      continue;

    if (child->pack == CTK_PACK_END)
(* callback) (child->widget, callback_data);
  }
2693}

2695GList *
2696_ctk_box_get_children (CtkBox *box)
2697{
CtkBoxPrivate *priv;
CtkBoxChild *child;
GList *children;
GList *retval = NULL((void*)0);

g_return_val_if_fail (CTK_IS_BOX (box), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return (((void*)0)); } } while (0);

priv = box->priv;

children = priv->children;
while (children)
  {
    child = children->data;
    children = children->next;

    retval = g_list_prepend (retval, child->widget);
  }

return g_list_reverse (retval);
2717}

2719/**
* ctk_box_set_center_widget:
* @box: a #CtkBox
* @widget: (allow-none): the widget to center
*
* Sets a center widget; that is a child widget that will be
* centered with respect to the full width of the box, even
* if the children at either side take up different amounts
* of space.
*
* Since: 3.12
*/
2731void
2732ctk_box_set_center_widget (CtkBox    *box,
                         CtkWidget *widget)
2734{
CtkBoxPrivate *priv = box->priv;
CtkWidget *old_center = NULL((void*)0);

g_return_if_fail (CTK_IS_BOX (box))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return; } } while (0);

if (priv->center)
  {
    old_center = g_object_ref (priv->center->widget)((__typeof__ (priv->center->widget)) (g_object_ref) (priv
->center->widget));
    ctk_box_remove (CTK_CONTAINER (box)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((box)), ((ctk_container_get_type ())))))), priv->center->widget);
    priv->center = NULL((void*)0);
  }

if (widget)
  priv->center = ctk_box_pack (box, widget, FALSE(0), TRUE(!(0)), 0, CTK_PACK_START);

if (old_center)
  g_object_unref (old_center);
2752}

2754/**
* ctk_box_get_center_widget:
* @box: a #CtkBox
*
* Retrieves the center widget of the box.
*
* Returns: (transfer none) (nullable): the center widget
*   or %NULL in case no center widget is set.
*
* Since: 3.12
*/
2765CtkWidget *
2766ctk_box_get_center_widget (CtkBox *box)
2767{
CtkBoxPrivate *priv = box->priv;

g_return_val_if_fail (CTK_IS_BOX (box), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((box)); GType __t = ((ctk_box_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_BOX (box)"); return (((void*)0)); } } while (0);

if (priv->center)
  return priv->center->widget;

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