ctkgrid.c

Bug Summary

File:	ctk/ctkgrid.c
Warning:	line 979, column 7 Access of 'struct _CtkGridLine' element in the memory returned by 'alloca' at index 1
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 ctkgrid.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-19-110847-43636-1 -x c ctkgrid.c
1/* CTK - The GIMP Toolkit
* Copyright (C) 2010 Red Hat, Inc.
* Author: Matthias Clasen
*
* 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/>.
*/

19#include "config.h"

21#include <string.h>

23#include "ctkgrid.h"

25#include "ctkorientableprivate.h"
26#include "ctkrender.h"
27#include "ctksizerequest.h"
28#include "ctkwidgetprivate.h"
29#include "ctkcontainerprivate.h"
30#include "ctkcsscustomgadgetprivate.h"
31#include "ctkprivate.h"
32#include "ctkintl.h"


35/**
* SECTION:ctkgrid
* @Short_description: Pack widgets in rows and columns
* @Title: CtkGrid
* @See_also: #CtkBox
*
* CtkGrid is a container which arranges its child widgets in
* rows and columns, with arbitrary positions and horizontal/vertical spans.
*
* Children are added using ctk_grid_attach(). They can span multiple
* rows or columns. It is also possible to add a child next to an
* existing child, using ctk_grid_attach_next_to(). The behaviour of
* CtkGrid when several children occupy the same grid cell is undefined.
*
* CtkGrid can be used like a #CtkBox by just using ctk_container_add(),
* which will place children next to each other in the direction determined
* by the #CtkOrientable:orientation property. However, if all you want is a
* single row or column, then #CtkBox is the preferred widget.
*
* # CSS nodes
*
* CtkGrid uses a single CSS node with name grid.
*/

59typedef struct _CtkGridChild CtkGridChild;
60typedef struct _CtkGridChildAttach CtkGridChildAttach;
61typedef struct _CtkGridRowProperties CtkGridRowProperties;
62typedef struct _CtkGridLine CtkGridLine;
63typedef struct _CtkGridLines CtkGridLines;
64typedef struct _CtkGridLineData CtkGridLineData;
65typedef struct _CtkGridRequest CtkGridRequest;

67struct _CtkGridChildAttach
68{
gint pos;
gint span;
71};

73struct _CtkGridRowProperties
74{
gint row;
CtkBaselinePosition baseline_position;
77};

79static const CtkGridRowProperties ctk_grid_row_properties_default = {
0,
CTK_BASELINE_POSITION_CENTER
82};

84struct _CtkGridChild
85{
CtkWidget *widget;
CtkGridChildAttach attach[2];
88};

90#define CHILD_LEFT(child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos)    ((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos)
91#define CHILD_WIDTH(child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span)   ((child)->attach[CTK_ORIENTATION_HORIZONTAL].span)
92#define CHILD_TOP(child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos)     ((child)->attach[CTK_ORIENTATION_VERTICAL].pos)
93#define CHILD_HEIGHT(child)((child)->attach[CTK_ORIENTATION_VERTICAL].span)  ((child)->attach[CTK_ORIENTATION_VERTICAL].span)

95/* A CtkGridLineData struct contains row/column specific parts
* of the grid.
*/
98struct _CtkGridLineData
99{
gint16 spacing;
guint homogeneous : 1;
102};

104struct _CtkGridPrivate
105{
GList *children;
GList *row_properties;

CtkCssGadget *gadget;

CtkOrientation orientation;
gint baseline_row;

CtkGridLineData linedata[2];
115};

117#define ROWS(priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])    (&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])
118#define COLUMNS(priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL]) (&(priv)->linedata[CTK_ORIENTATION_VERTICAL])

120/* A CtkGridLine struct represents a single row or column
* during size requests
*/
123struct _CtkGridLine
124{
gint minimum;
gint natural;
gint minimum_above;
gint minimum_below;
gint natural_above;
gint natural_below;

gint position;
gint allocation;
gint allocated_baseline;

guint need_expand : 1;
guint expand      : 1;
guint empty       : 1;
139};

141struct _CtkGridLines
142{
CtkGridLine *lines;
gint min, max;
145};

147struct _CtkGridRequest
148{
CtkGrid *grid;
CtkGridLines lines[2];
151};


154enum
155{
PROP_0,
PROP_ROW_SPACING,
PROP_COLUMN_SPACING,
PROP_ROW_HOMOGENEOUS,
PROP_COLUMN_HOMOGENEOUS,
PROP_BASELINE_ROW,
N_PROPERTIES,
PROP_ORIENTATION
164};

166static GParamSpec *obj_properties[N_PROPERTIES] = { NULL((void*)0), };

168enum
169{
CHILD_PROP_0,
CHILD_PROP_LEFT_ATTACH,
CHILD_PROP_TOP_ATTACH,
CHILD_PROP_WIDTH,
CHILD_PROP_HEIGHT,
N_CHILD_PROPERTIES
176};

178static GParamSpec *child_properties[N_CHILD_PROPERTIES] = { NULL((void*)0), };

180G_DEFINE_TYPE_WITH_CODE (CtkGrid, ctk_grid, CTK_TYPE_CONTAINER,static void ctk_grid_init (CtkGrid *self); static void ctk_grid_class_init
 (CtkGridClass *klass); static GType ctk_grid_get_type_once (
void); static gpointer ctk_grid_parent_class = ((void*)0); static
 gint CtkGrid_private_offset; static void ctk_grid_class_intern_init
 (gpointer klass) { ctk_grid_parent_class = g_type_class_peek_parent
 (klass); if (CtkGrid_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkGrid_private_offset); ctk_grid_class_init ((
CtkGridClass*) klass); } __attribute__ ((__unused__)) static inline
 gpointer ctk_grid_get_instance_private (CtkGrid *self) { return
 (((gpointer) ((guint8*) (self) + (glong) (CtkGrid_private_offset
)))); } GType ctk_grid_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_grid_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_grid_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkGrid"), sizeof (CtkGridClass
), (GClassInitFunc)(void (*)(void)) ctk_grid_class_intern_init
, sizeof (CtkGrid), (GInstanceInitFunc)(void (*)(void)) ctk_grid_init
, (GTypeFlags) 0); { {{ CtkGrid_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkGridPrivate)); } { 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
); };} } return g_define_type_id; }
                       G_ADD_PRIVATE (CtkGrid)static void ctk_grid_init (CtkGrid *self); static void ctk_grid_class_init
 (CtkGridClass *klass); static GType ctk_grid_get_type_once (
void); static gpointer ctk_grid_parent_class = ((void*)0); static
 gint CtkGrid_private_offset; static void ctk_grid_class_intern_init
 (gpointer klass) { ctk_grid_parent_class = g_type_class_peek_parent
 (klass); if (CtkGrid_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkGrid_private_offset); ctk_grid_class_init ((
CtkGridClass*) klass); } __attribute__ ((__unused__)) static inline
 gpointer ctk_grid_get_instance_private (CtkGrid *self) { return
 (((gpointer) ((guint8*) (self) + (glong) (CtkGrid_private_offset
)))); } GType ctk_grid_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_grid_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_grid_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkGrid"), sizeof (CtkGridClass
), (GClassInitFunc)(void (*)(void)) ctk_grid_class_intern_init
, sizeof (CtkGrid), (GInstanceInitFunc)(void (*)(void)) ctk_grid_init
, (GTypeFlags) 0); { {{ CtkGrid_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkGridPrivate)); } { 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
); };} } return g_define_type_id; }
                       G_IMPLEMENT_INTERFACE (CTK_TYPE_ORIENTABLE, NULL))static void ctk_grid_init (CtkGrid *self); static void ctk_grid_class_init
 (CtkGridClass *klass); static GType ctk_grid_get_type_once (
void); static gpointer ctk_grid_parent_class = ((void*)0); static
 gint CtkGrid_private_offset; static void ctk_grid_class_intern_init
 (gpointer klass) { ctk_grid_parent_class = g_type_class_peek_parent
 (klass); if (CtkGrid_private_offset != 0) g_type_class_adjust_private_offset
 (klass, &CtkGrid_private_offset); ctk_grid_class_init ((
CtkGridClass*) klass); } __attribute__ ((__unused__)) static inline
 gpointer ctk_grid_get_instance_private (CtkGrid *self) { return
 (((gpointer) ((guint8*) (self) + (glong) (CtkGrid_private_offset
)))); } GType ctk_grid_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_grid_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_grid_get_type_once (void) { GType
 g_define_type_id = g_type_register_static_simple ((ctk_container_get_type
 ()), g_intern_static_string ("CtkGrid"), sizeof (CtkGridClass
), (GClassInitFunc)(void (*)(void)) ctk_grid_class_intern_init
, sizeof (CtkGrid), (GInstanceInitFunc)(void (*)(void)) ctk_grid_init
, (GTypeFlags) 0); { {{ CtkGrid_private_offset = g_type_add_instance_private
 (g_define_type_id, sizeof (CtkGridPrivate)); } { 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
); };} } return g_define_type_id; }


185static void ctk_grid_row_properties_free (CtkGridRowProperties *props);

187static void
188ctk_grid_get_property (GObject    *object,
                     guint       prop_id,
                     GValue     *value,
                     GParamSpec *pspec)
192{
CtkGrid *grid = CTK_GRID (object)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_grid_get_type ()))))));
CtkGridPrivate *priv = grid->priv;

switch (prop_id)
  {
  case PROP_ORIENTATION:
    g_value_set_enum (value, priv->orientation);
    break;

  case PROP_ROW_SPACING:
    g_value_set_int (value, COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->spacing);
    break;

  case PROP_COLUMN_SPACING:
    g_value_set_int (value, ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->spacing);
    break;

  case PROP_ROW_HOMOGENEOUS:
    g_value_set_boolean (value, COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->homogeneous);
    break;

  case PROP_COLUMN_HOMOGENEOUS:
    g_value_set_boolean (value, ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->homogeneous);
    break;

  case PROP_BASELINE_ROW:
    g_value_set_int (value, priv->baseline_row);
    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'"
, "ctkgrid.c", 223, ("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;
  }
226}

228static void
229ctk_grid_set_orientation (CtkGrid        *grid,
                        CtkOrientation  orientation)
231{
CtkGridPrivate *priv = grid->priv;

if (priv->orientation != orientation)
  {
    priv->orientation = orientation;
    _ctk_orientable_set_style_classes (CTK_ORIENTABLE (grid)((((CtkOrientable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_orientable_get_type ())))))));

    g_object_notify (G_OBJECT (grid)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), (((GType) ((20) << (2)))))))), "orientation");
  }
241}

243static void
244ctk_grid_set_property (GObject      *object,
                     guint         prop_id,
                     const GValue *value,
                     GParamSpec   *pspec)
248{
CtkGrid *grid = CTK_GRID (object)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_grid_get_type ()))))));

switch (prop_id)
  {
  case PROP_ORIENTATION:
    ctk_grid_set_orientation (grid, g_value_get_enum (value));
    break;

  case PROP_ROW_SPACING:
    ctk_grid_set_row_spacing (grid, g_value_get_int (value));
    break;

  case PROP_COLUMN_SPACING:
    ctk_grid_set_column_spacing (grid, g_value_get_int (value));
    break;

  case PROP_ROW_HOMOGENEOUS:
    ctk_grid_set_row_homogeneous (grid, g_value_get_boolean (value));
    break;

  case PROP_COLUMN_HOMOGENEOUS:
    ctk_grid_set_column_homogeneous (grid, g_value_get_boolean (value));
    break;

  case PROP_BASELINE_ROW:
    ctk_grid_set_baseline_row (grid, g_value_get_int (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'"
, "ctkgrid.c", 278, ("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;
  }
281}

283static CtkGridChild *
284find_grid_child (CtkGrid   *grid,
               CtkWidget *widget)
286{
CtkGridPrivate *priv = grid->priv;
CtkGridChild *child;
GList *list;

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

    if (child->widget == widget)
      return child;
  }

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

302static void
303ctk_grid_get_child_property (CtkContainer *container,
                           CtkWidget    *child,
                           guint         property_id,
                           GValue       *value,
                           GParamSpec   *pspec)
308{
CtkGrid *grid = CTK_GRID (container)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_grid_get_type ()))))));
CtkGridChild *grid_child;

grid_child = find_grid_child (grid, child);

if (grid_child == NULL((void*)0))
  {
    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'"
, "ctkgrid.c", 316, ("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);
    return;
  }

switch (property_id)
  {
  case CHILD_PROP_LEFT_ATTACH:
    g_value_set_int (value, CHILD_LEFT (grid_child)((grid_child)->attach[CTK_ORIENTATION_HORIZONTAL].pos));
    break;

  case CHILD_PROP_TOP_ATTACH:
    g_value_set_int (value, CHILD_TOP (grid_child)((grid_child)->attach[CTK_ORIENTATION_VERTICAL].pos));
    break;

  case CHILD_PROP_WIDTH:
    g_value_set_int (value, CHILD_WIDTH (grid_child)((grid_child)->attach[CTK_ORIENTATION_HORIZONTAL].span));
    break;

  case CHILD_PROP_HEIGHT:
    g_value_set_int (value, CHILD_HEIGHT (grid_child)((grid_child)->attach[CTK_ORIENTATION_VERTICAL].span));
    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'"
, "ctkgrid.c", 339, ("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;
  }
342}

344static void
345ctk_grid_set_child_property (CtkContainer *container,
                           CtkWidget    *child,
                           guint         property_id,
                           const GValue *value,
                           GParamSpec   *pspec)
350{
CtkGrid *grid = CTK_GRID (container)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_grid_get_type ()))))));
CtkGridChild *grid_child;

grid_child = find_grid_child (grid, child);

if (grid_child == NULL((void*)0))
  {
    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'"
, "ctkgrid.c", 358, ("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);
    return;
  }

switch (property_id)
  {
  case CHILD_PROP_LEFT_ATTACH:
    CHILD_LEFT (grid_child)((grid_child)->attach[CTK_ORIENTATION_HORIZONTAL].pos) = g_value_get_int (value);
    break;

  case CHILD_PROP_TOP_ATTACH:
    CHILD_TOP (grid_child)((grid_child)->attach[CTK_ORIENTATION_VERTICAL].pos) = g_value_get_int (value);
    break;

 case CHILD_PROP_WIDTH:
    CHILD_WIDTH (grid_child)((grid_child)->attach[CTK_ORIENTATION_HORIZONTAL].span) = g_value_get_int (value);
    break;

  case CHILD_PROP_HEIGHT:
    CHILD_HEIGHT (grid_child)((grid_child)->attach[CTK_ORIENTATION_VERTICAL].span) = 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'"
, "ctkgrid.c", 381, ("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;
  }

if (_ctk_widget_get_visible (child) &&
    _ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
  ctk_widget_queue_resize (child);
388}

390static void
391ctk_grid_finalize (GObject *object)
392{
CtkGrid *grid = CTK_GRID (object)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((object)), ((ctk_grid_get_type ()))))));
CtkGridPrivate *priv = grid->priv;

g_list_free_full (priv->row_properties, (GDestroyNotify)ctk_grid_row_properties_free);

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_grid_parent_class)((((GObjectClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_grid_parent_class)), (((GType) ((20) << (2))))
))))->finalize (object);
401}

403static void
404grid_attach (CtkGrid   *grid,
           CtkWidget *widget,
           gint       left,
           gint       top,
           gint       width,
           gint       height)
410{
CtkGridPrivate *priv = grid->priv;
CtkGridChild *child;

child = g_slice_new (CtkGridChild)((CtkGridChild*) g_slice_alloc (sizeof (CtkGridChild)));
child->widget = widget;
CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos) = left;
CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos) = top;
CHILD_WIDTH (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span) = width;
CHILD_HEIGHT (child)((child)->attach[CTK_ORIENTATION_VERTICAL].span) = height;

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

ctk_widget_set_parent (widget, CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));
424}

426/* Find the position 'touching' existing
* children. @orientation and @max determine
* from which direction to approach (horizontal
* + max = right, vertical + !max = top, etc).
* @op_pos, @op_span determine the rows/columns
* in which the touching has to happen.
*/
433static gint
434find_attach_position (CtkGrid         *grid,
                    CtkOrientation   orientation,
                    gint             op_pos,
                    gint             op_span,
                    gboolean         max)
439{
CtkGridPrivate *priv = grid->priv;
CtkGridChild *grid_child;
CtkGridChildAttach *attach;
CtkGridChildAttach *opposite;
GList *list;
gint pos;
gboolean hit;

if (max)
  pos = -G_MAXINT2147483647;
else
  pos = G_MAXINT2147483647;

hit = FALSE(0);

for (list = priv->children; list; list = list->next)
  {
    grid_child = list->data;

    attach = &grid_child->attach[orientation];
    opposite = &grid_child->attach[1 - orientation];

    /* check if the ranges overlap */
    if (opposite->pos <= op_pos + op_span && op_pos <= opposite->pos + opposite->span)
      {
        hit = TRUE(!(0));

        if (max)
          pos = MAX (pos, attach->pos + attach->span)(((pos) > (attach->pos + attach->span)) ? (pos) : (attach
->pos + attach->span));
        else
          pos = MIN (pos, attach->pos)(((pos) < (attach->pos)) ? (pos) : (attach->pos));
      }
   }

if (!hit)
  pos = 0;

return pos;
478}

480static void
481ctk_grid_add (CtkContainer *container,
            CtkWidget    *child)
483{
CtkGrid *grid = CTK_GRID (container)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_grid_get_type ()))))));
CtkGridPrivate *priv = grid->priv;
gint pos[2] = { 0, 0 };

pos[priv->orientation] = find_attach_position (grid, priv->orientation, 0, 1, TRUE(!(0)));
grid_attach (grid, child, pos[0], pos[1], 1, 1);
490}

492static void
493ctk_grid_remove (CtkContainer *container,
               CtkWidget    *child)
495{
CtkGrid *grid = CTK_GRID (container)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_grid_get_type ()))))));
CtkGridPrivate *priv = grid->priv;
CtkGridChild *grid_child;
GList *list;

for (list = priv->children; list; list = list->next)
  {
    grid_child = list->data;

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

        ctk_widget_unparent (child);

        priv->children = g_list_remove (priv->children, grid_child);

        g_slice_free (CtkGridChild, grid_child)do { if (1) g_slice_free1 (sizeof (CtkGridChild), (grid_child
)); else (void) ((CtkGridChild*) 0 == (grid_child)); } while (
0);

        if (was_visible && _ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
          ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));

        break;
      }
  }
521}

523static void
524ctk_grid_forall (CtkContainer *container,
               gboolean      include_internals G_GNUC_UNUSED__attribute__ ((__unused__)),
               CtkCallback   callback,
               gpointer      callback_data)
528{
CtkGrid *grid = CTK_GRID (container)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((container)), ((ctk_grid_get_type ()))))));
CtkGridPrivate *priv = grid->priv;
CtkGridChild *child;
GList *list;

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

    (* callback) (child->widget, callback_data);
  }
542}

544static GType
545ctk_grid_child_type (CtkContainer *container G_GNUC_UNUSED__attribute__ ((__unused__)))
546{
return CTK_TYPE_WIDGET(ctk_widget_get_type ());
548}

550/* Calculates the min and max numbers for both orientations.
*/
552static void
553ctk_grid_request_count_lines (CtkGridRequest *request)
554{
CtkGridPrivate *priv = request->grid->priv;
CtkGridChild *child;
CtkGridChildAttach *attach;
GList *list;
gint min[2];
gint max[2];

min[0] = min[1] = G_MAXINT2147483647;
max[0] = max[1] = G_MININT(-2147483647 -1);

for (list = priv->children; list; list = list->next)
  {
    child = list->data;
    attach = child->attach;

    min[0] = MIN (min[0], attach[0].pos)(((min[0]) < (attach[0].pos)) ? (min[0]) : (attach[0].pos)
);
    max[0] = MAX (max[0], attach[0].pos + attach[0].span)(((max[0]) > (attach[0].pos + attach[0].span)) ? (max[0]) :
 (attach[0].pos + attach[0].span));
    min[1] = MIN (min[1], attach[1].pos)(((min[1]) < (attach[1].pos)) ? (min[1]) : (attach[1].pos)
);
    max[1] = MAX (max[1], attach[1].pos + attach[1].span)(((max[1]) > (attach[1].pos + attach[1].span)) ? (max[1]) :
 (attach[1].pos + attach[1].span));
  }

request->lines[0].min = min[0];
request->lines[0].max = max[0];
request->lines[1].min = min[1];
request->lines[1].max = max[1];
580}

582/* Sets line sizes to 0 and marks lines as expand
* if they have a non-spanning expanding child.
*/
585static void
586ctk_grid_request_init (CtkGridRequest *request,
                     CtkOrientation  orientation)
588{
CtkGridPrivate *priv = request->grid->priv;
CtkGridChild *child;
CtkGridChildAttach *attach;
CtkGridLines *lines;
GList *list;
gint i;

lines = &request->lines[orientation];

for (i = 0; i < lines->max - lines->min; i++)
  {
    lines->lines[i].minimum = 0;
    lines->lines[i].natural = 0;
    lines->lines[i].minimum_above = -1;
    lines->lines[i].minimum_below = -1;
    lines->lines[i].natural_above = -1;
    lines->lines[i].natural_below = -1;
    lines->lines[i].expand = FALSE(0);
    lines->lines[i].empty = TRUE(!(0));
  }

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

    attach = &child->attach[orientation];
    if (attach->span == 1 && ctk_widget_compute_expand (child->widget, orientation))
      lines->lines[attach->pos - lines->min].expand = TRUE(!(0));
  }
618}

620/* Sums allocations for lines spanned by child and their spacing.
*/
622static gint
623compute_allocation_for_child (CtkGridRequest *request,
                            CtkGridChild   *child,
                            CtkOrientation  orientation)
626{
CtkGridPrivate *priv = request->grid->priv;
CtkGridLineData *linedata;
CtkGridLines *lines;
CtkGridLine *line;
CtkGridChildAttach *attach;
gint size;
gint i;

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];
attach = &child->attach[orientation];

size = (attach->span - 1) * linedata->spacing;
for (i = 0; i < attach->span; i++)
  {
    line = &lines->lines[attach->pos - lines->min + i];
    size += line->allocation;
  }

return size;
647}

649static void
650compute_request_for_child (CtkGridRequest *request,
                         CtkGridChild   *child,
                         CtkOrientation  orientation,
                         gboolean        contextual,
                         gint           *minimum,
                         gint           *natural,
	   gint           *minimum_baseline,
                         gint           *natural_baseline)
658{
if (minimum_baseline)
  *minimum_baseline = -1;
if (natural_baseline)
  *natural_baseline = -1;
if (contextual)
  {
    gint size;

    size = compute_allocation_for_child (request, child, 1 - orientation);
    if (orientation == CTK_ORIENTATION_HORIZONTAL)
      ctk_widget_get_preferred_width_for_height (child->widget,
                                                 size,
                                                 minimum, natural);
    else
      ctk_widget_get_preferred_height_and_baseline_for_width (child->widget,
						size,
						minimum, natural,
						minimum_baseline, natural_baseline);
  }
else
  {
    if (orientation == CTK_ORIENTATION_HORIZONTAL)
      ctk_widget_get_preferred_width (child->widget, minimum, natural);
    else
      ctk_widget_get_preferred_height_and_baseline_for_width (child->widget,
						-1,
						minimum, natural,
						minimum_baseline, natural_baseline);
  }
688}

690/* Sets requisition to max. of non-spanning children.
* If contextual is TRUE, requires allocations of
* lines in the opposite orientation to be set.
*/
694static void
695ctk_grid_request_non_spanning (CtkGridRequest *request,
                             CtkOrientation  orientation,
                             gboolean        contextual)
698{
CtkGridPrivate *priv = request->grid->priv;
CtkGridChild *child;
CtkGridChildAttach *attach;
CtkGridLines *lines;
CtkGridLine *line;
GList *list;
gint i;
CtkBaselinePosition baseline_pos;
gint minimum, minimum_baseline;
gint natural, natural_baseline;

lines = &request->lines[orientation];

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

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

    attach = &child->attach[orientation];
    if (attach->span != 1)
      continue;

    compute_request_for_child (request, child, orientation, contextual, &minimum, &natural, &minimum_baseline, &natural_baseline);

    line = &lines->lines[attach->pos - lines->min];

    if (minimum_baseline != -1)
{
 line->minimum_above = MAX (line->minimum_above, minimum_baseline)(((line->minimum_above) > (minimum_baseline)) ? (line->
minimum_above) : (minimum_baseline));
 line->minimum_below = MAX (line->minimum_below, minimum - minimum_baseline)(((line->minimum_below) > (minimum - minimum_baseline))
 ? (line->minimum_below) : (minimum - minimum_baseline));
 line->natural_above = MAX (line->natural_above, natural_baseline)(((line->natural_above) > (natural_baseline)) ? (line->
natural_above) : (natural_baseline));
 line->natural_below = MAX (line->natural_below, natural - natural_baseline)(((line->natural_below) > (natural - natural_baseline))
 ? (line->natural_below) : (natural - natural_baseline));
}
    else
{
 line->minimum = MAX (line->minimum, minimum)(((line->minimum) > (minimum)) ? (line->minimum) : (
minimum));
 line->natural = MAX (line->natural, natural)(((line->natural) > (natural)) ? (line->natural) : (
natural));
}
  }

for (i = 0; i < lines->max - lines->min; i++)
  {
    line = &lines->lines[i];

    if (line->minimum_above != -1)
{
 line->minimum = MAX (line->minimum, line->minimum_above + line->minimum_below)(((line->minimum) > (line->minimum_above + line->
minimum_below)) ? (line->minimum) : (line->minimum_above
 + line->minimum_below));
 line->natural = MAX (line->natural, line->natural_above + line->natural_below)(((line->natural) > (line->natural_above + line->
natural_below)) ? (line->natural) : (line->natural_above
 + line->natural_below));

 baseline_pos = ctk_grid_get_row_baseline_position (request->grid, i + lines->min);

 switch (baseline_pos)
   {
   case CTK_BASELINE_POSITION_TOP:
     line->minimum_above += 0;
     line->minimum_below += line->minimum - (line->minimum_above + line->minimum_below);
     line->natural_above += 0;
     line->natural_below += line->natural - (line->natural_above + line->natural_below);
     break;
   case CTK_BASELINE_POSITION_CENTER:
     line->minimum_above += (line->minimum - (line->minimum_above + line->minimum_below))/2;
     line->minimum_below += (line->minimum - (line->minimum_above + line->minimum_below))/2;
     line->natural_above += (line->natural - (line->natural_above + line->natural_below))/2;
     line->natural_below += (line->natural - (line->natural_above + line->natural_below))/2;
     break;
   case CTK_BASELINE_POSITION_BOTTOM:
     line->minimum_above += line->minimum - (line->minimum_above + line->minimum_below);
     line->minimum_below += 0;
     line->natural_above += line->natural - (line->natural_above + line->natural_below);
     line->natural_below += 0;
     break;
   }
}
  }
775}

777/* Enforce homogeneous sizes.
*/
779static void
780ctk_grid_request_homogeneous (CtkGridRequest *request,
                            CtkOrientation  orientation)
782{
CtkGridPrivate *priv = request->grid->priv;
CtkGridLineData *linedata;
CtkGridLines *lines;
gint minimum, natural;
gint i;

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];

if (!linedata->homogeneous)
  return;

minimum = 0;
natural = 0;

for (i = 0; i < lines->max - lines->min; i++)
  {
    minimum = MAX (minimum, lines->lines[i].minimum)(((minimum) > (lines->lines[i].minimum)) ? (minimum) : (
lines->lines[i].minimum));
    natural = MAX (natural, lines->lines[i].natural)(((natural) > (lines->lines[i].natural)) ? (natural) : (
lines->lines[i].natural));
  }

for (i = 0; i < lines->max - lines->min; i++)
  {
    lines->lines[i].minimum = minimum;
    lines->lines[i].natural = natural;
    /* TODO: Do we want to adjust the baseline here too?
     * And if so, also in the homogenous resize.
     */
  }
812}

814/* Deals with spanning children.
* Requires expand fields of lines to be set for
* non-spanning children.
*/
818static void
819ctk_grid_request_spanning (CtkGridRequest *request,
                         CtkOrientation  orientation,
                         gboolean        contextual)
822{
CtkGridPrivate *priv = request->grid->priv;
GList *list;
CtkGridChild *child;
CtkGridChildAttach *attach;
CtkGridLineData *linedata;
CtkGridLines *lines;
CtkGridLine *line;
gint minimum;
gint natural;
gint span_minimum;
gint span_natural;
gint span_expand;
gboolean force_expand;
gint extra;
gint expand;
gint line_extra;
gint i;

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];

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

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

    attach = &child->attach[orientation];
    if (attach->span == 1)
      continue;

    /* We ignore baselines for spanning children */
    compute_request_for_child (request, child, orientation, contextual, &minimum, &natural, NULL((void*)0), NULL((void*)0));

    span_minimum = (attach->span - 1) * linedata->spacing;
    span_natural = (attach->span - 1) * linedata->spacing;
    span_expand = 0;
    force_expand = FALSE(0);
    for (i = 0; i < attach->span; i++)
      {
        line = &lines->lines[attach->pos - lines->min + i];
        span_minimum += line->minimum;
        span_natural += line->natural;
        if (line->expand)
          span_expand += 1;
      }
    if (span_expand == 0)
      {
        span_expand = attach->span;
        force_expand = TRUE(!(0));
      }

    /* If we need to request more space for this child to fill
     * its requisition, then divide up the needed space amongst the
     * lines it spans, favoring expandable lines if any.
     *
     * When doing homogeneous allocation though, try to keep the
     * line allocations even, since we're going to force them to
     * be the same anyway, and we don't want to introduce unnecessary
     * extra space.
     */
    if (span_minimum < minimum)
      {
        if (linedata->homogeneous)
          {
            gint total, m;

            total = minimum - (attach->span - 1) * linedata->spacing;
            m = total / attach->span + (total % attach->span ? 1 : 0);
            for (i = 0; i < attach->span; i++)
              {
                line = &lines->lines[attach->pos - lines->min + i];
                line->minimum = MAX(line->minimum, m)(((line->minimum) > (m)) ? (line->minimum) : (m));
              }
          }
        else
          {
            extra = minimum - span_minimum;
            expand = span_expand;
            for (i = 0; i < attach->span; i++)
              {
                line = &lines->lines[attach->pos - lines->min + i];
                if (force_expand || line->expand)
                  {
                    line_extra = extra / expand;
                    line->minimum += line_extra;
                    extra -= line_extra;
                    expand -= 1;
                  }
              }
          }
      }

    if (span_natural < natural)
      {
        if (linedata->homogeneous)
          {
            gint total, n;

            total = natural - (attach->span - 1) * linedata->spacing;
            n = total / attach->span + (total % attach->span ? 1 : 0);
            for (i = 0; i < attach->span; i++)
              {
                line = &lines->lines[attach->pos - lines->min + i];
                line->natural = MAX(line->natural, n)(((line->natural) > (n)) ? (line->natural) : (n));
              }
          }
        else
          {
            extra = natural - span_natural;
            expand = span_expand;
            for (i = 0; i < attach->span; i++)
              {
                line = &lines->lines[attach->pos - lines->min + i];
                if (force_expand || line->expand)
                  {
                    line_extra = extra / expand;
                    line->natural += line_extra;
                    extra -= line_extra;
                    expand -= 1;
                  }
              }
          }
      }
  }
949}

951/* Marks empty and expanding lines and counts them.
*/
953static void
954ctk_grid_request_compute_expand (CtkGridRequest *request,
                               CtkOrientation  orientation,
		 gint            min,
		 gint            max,
                               gint           *nonempty_lines,
                               gint           *expand_lines)
960{
CtkGridPrivate *priv = request->grid->priv;
CtkGridChild *child;
CtkGridChildAttach *attach;
GList *list;
gint i;
CtkGridLines *lines;
CtkGridLine *line;
gboolean has_expand;
gint expand;
gint empty;

lines = &request->lines[orientation];

min = MAX (min, lines->min)(((min) > (lines->min)) ? (min) : (lines->min));
14
←
'?' condition is false→
max = MIN (max, lines->max)(((max) < (lines->max)) ? (max) : (lines->max));
15
←
'?' condition is true→

for (i = min - lines->min; i < max - lines->min; i++)
16
←
Assuming the condition is true→
17
←
Loop condition is true.  Entering loop body→
18
←
Assuming the condition is true→
19
←
Loop condition is true.  Entering loop body→
  {
    lines->lines[i].need_expand = FALSE(0);
20
←
Access of 'struct _CtkGridLine' element in the memory returned by 'alloca' at index 1
    lines->lines[i].expand = FALSE(0);
    lines->lines[i].empty = TRUE(!(0));
  }

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

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

    attach = &child->attach[orientation];
    if (attach->span != 1)
      continue;

    if (attach->pos >= max || attach->pos < min)
continue;

    line = &lines->lines[attach->pos - lines->min];
    line->empty = FALSE(0);
    if (ctk_widget_compute_expand (child->widget, orientation))
      line->expand = TRUE(!(0));
  }

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

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

    attach = &child->attach[orientation];
    if (attach->span == 1)
      continue;

    has_expand = FALSE(0);
    for (i = 0; i < attach->span; i++)
      {
        line = &lines->lines[attach->pos - lines->min + i];

        if (line->expand)
          has_expand = TRUE(!(0));

 if (attach->pos + i >= max || attach->pos + 1 < min)
   continue;

        line->empty = FALSE(0);
      }

    if (!has_expand && ctk_widget_compute_expand (child->widget, orientation))
      {
        for (i = 0; i < attach->span; i++)
          {
     if (attach->pos + i >= max || attach->pos + 1 < min)
continue;

            line = &lines->lines[attach->pos - lines->min + i];
            line->need_expand = TRUE(!(0));
          }
      }
  }

empty = 0;
expand = 0;
for (i = min - lines->min; i < max - lines->min; i++)
  {
    line = &lines->lines[i];

    if (line->need_expand)
      line->expand = TRUE(!(0));

    if (line->empty)
      empty += 1;

    if (line->expand)
      expand += 1;
  }

if (nonempty_lines)
  *nonempty_lines = max - min - empty;

if (expand_lines)
  *expand_lines = expand;
1063}

1065/* Sums the minimum and natural fields of lines and their spacing.
*/
1067static void
1068ctk_grid_request_sum (CtkGridRequest *request,
                    CtkOrientation  orientation,
                    gint           *minimum,
                    gint           *natural,
      gint           *minimum_baseline,
      gint           *natural_baseline)
1074{
CtkGridPrivate *priv = request->grid->priv;
CtkGridLineData *linedata;
CtkGridLines *lines;
gint i;
gint min, nat;
gint nonempty;

ctk_grid_request_compute_expand (request, orientation, G_MININT(-2147483647 -1), G_MAXINT2147483647, &nonempty, NULL((void*)0));

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];

min = 0;
nat = 0;
for (i = 0; i < lines->max - lines->min; i++)
  {
    if (orientation == CTK_ORIENTATION_VERTICAL &&
 lines->min + i == priv->baseline_row &&
 lines->lines[i].minimum_above != -1)
{
 if (minimum_baseline)
   *minimum_baseline = min + lines->lines[i].minimum_above;
 if (natural_baseline)
   *natural_baseline = nat + lines->lines[i].natural_above;
}

    min += lines->lines[i].minimum;
    nat += lines->lines[i].natural;

    if (!lines->lines[i].empty)
{
 min += linedata->spacing;
 nat += linedata->spacing;
}
  }

/* Remove last spacing, if any was applied */
if (nonempty > 0)
  {
    min -= linedata->spacing;
    nat -= linedata->spacing;
  }

*minimum = min;
*natural = nat;
1120}

1122/* Computes minimum and natural fields of lines.
* When contextual is TRUE, requires allocation of
* lines in the opposite orientation to be set.
*/
1126static void
1127ctk_grid_request_run (CtkGridRequest *request,
                    CtkOrientation  orientation,
                    gboolean        contextual)
1130{
ctk_grid_request_init (request, orientation);
ctk_grid_request_non_spanning (request, orientation, contextual);
ctk_grid_request_homogeneous (request, orientation);
ctk_grid_request_spanning (request, orientation, contextual);
ctk_grid_request_homogeneous (request, orientation);
1136}

1138static void
1139ctk_grid_distribute_non_homogeneous (CtkGridLines *lines,
		     gint nonempty,
		     gint expand,
		     gint size,
		     gint min,
		     gint max)
1145{
CtkRequestedSize *sizes;
CtkGridLine *line;
gint extra;
gint rest;
int i, j;

if (nonempty == 0)
  return;

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

j = 0;
for (i = min - lines->min; i < max - lines->min; i++)
  {
    line = &lines->lines[i];
    if (line->empty)
continue;

    size -= line->minimum;

    sizes[j].minimum_size = line->minimum;
    sizes[j].natural_size = line->natural;
    sizes[j].data = line;
    j++;
  }

size = ctk_distribute_natural_allocation (MAX (0, size)(((0) > (size)) ? (0) : (size)), nonempty, sizes);

if (expand > 0)
  {
    extra = size / expand;
    rest = size % expand;
  }
else
  {
    extra = 0;
    rest = 0;
  }

j = 0;
for (i = min - lines->min; i < max - lines->min; i++)
  {
    line = &lines->lines[i];
    if (line->empty)
continue;

    g_assert (line == sizes[j].data)do { if (line == sizes[j].data) ; else g_assertion_message_expr
 ("Ctk", "ctkgrid.c", 1192, ((const char*) (__func__)), "line == sizes[j].data"
); } while (0);

    line->allocation = sizes[j].minimum_size;
    if (line->expand)
{
 line->allocation += extra;
 if (rest > 0)
   {
     line->allocation += 1;
     rest -= 1;
   }
}

    j++;
  }
1207}

1209/* Requires that the minimum and natural fields of lines
* have been set, computes the allocation field of lines
* by distributing total_size among lines.
*/
1213static void
1214ctk_grid_request_allocate (CtkGridRequest *request,
                         CtkOrientation  orientation,
                         gint            total_size)
1217{
CtkGridPrivate *priv = request->grid->priv;
CtkGridLineData *linedata;
CtkGridLines *lines;
CtkGridLine *line;
gint nonempty1, nonempty2;
gint expand1, expand2;
gint i;
CtkBaselinePosition baseline_pos;
gint baseline;
gint extra, extra2;
gint rest;
gint size1, size2;
gint split, split_pos;

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];

baseline = ctk_widget_get_allocated_baseline (CTK_WIDGET (request->grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((request->grid)), ((ctk_widget_get_type ())))))));

if (orientation7.1
'orientation' is equal to CTK_ORIENTATION_VERTICAL
 == CTK_ORIENTATION_VERTICAL && baseline != -1 &&
8
←
Assuming the condition is true→
12
←
Taking true branch→
    priv->baseline_row >= lines->min && priv->baseline_row < lines->max &&
9
←
Assuming field 'baseline_row' is >= field 'min'→
10
←
Assuming field 'baseline_row' is < field 'max'→
    lines->lines[priv->baseline_row - lines->min].minimum_above != -1)
11
←
Assuming index is less than the number of 'CtkGridLine' elements in the memory returned by 'alloca'→
  {
    split = priv->baseline_row;
    split_pos = baseline - lines->lines[priv->baseline_row - lines->min].minimum_above;
    ctk_grid_request_compute_expand (request, orientation, lines->min, split, &nonempty1, &expand1);
13
←
Calling 'ctk_grid_request_compute_expand'→
    ctk_grid_request_compute_expand (request, orientation, split, lines->max, &nonempty2, &expand2);

    if (nonempty2 > 0)
{
 size1 = split_pos - (nonempty1) * linedata->spacing;
 size2 = (total_size - split_pos) - (nonempty2 - 1) * linedata->spacing;
}
    else
{
 size1 = total_size - (nonempty1 - 1) * linedata->spacing;
 size2 = 0;
}
  }
else
  {
    ctk_grid_request_compute_expand (request, orientation, lines->min, lines->max, &nonempty1, &expand1);
    nonempty2 = expand2 = 0;
    split = lines->max;

    size1 = total_size - (nonempty1 - 1) * linedata->spacing;
    size2 = 0;
  }

if (nonempty1 == 0 && nonempty2 == 0)
  return;

if (linedata->homogeneous)
  {
    if (nonempty1 > 0)
{
 extra = size1 / nonempty1;
 rest = size1 % nonempty1;
}
    else
{
 extra = 0;
 rest = 0;
}
    if (nonempty2 > 0)
{
 extra2 = size2 / nonempty2;
 if (extra2 < extra || nonempty1 == 0)
   {
     extra = extra2;
     rest = size2 % nonempty2;
   }
}

    for (i = 0; i < lines->max - lines->min; i++)
      {
        line = &lines->lines[i];
        if (line->empty)
          continue;

        line->allocation = extra;
        if (rest > 0)
          {
            line->allocation += 1;
            rest -= 1;
          }
      }
  }
else
  {
    ctk_grid_distribute_non_homogeneous (lines,
			   nonempty1,
			   expand1,
			   size1,
			   lines->min,
			   split);
    ctk_grid_distribute_non_homogeneous (lines,
			   nonempty2,
			   expand2,
			   size2,
			   split,
			   lines->max);
  }

for (i = 0; i < lines->max - lines->min; i++)
  {
    line = &lines->lines[i];
    if (line->empty)
continue;

    if (line->minimum_above != -1)
{
 /* Note: This is overridden in ctk_grid_request_position for the allocated baseline */
 baseline_pos = ctk_grid_get_row_baseline_position (request->grid, i + lines->min);

 switch (baseline_pos)
   {
   case CTK_BASELINE_POSITION_TOP:
     line->allocated_baseline =
line->minimum_above;
     break;
   case CTK_BASELINE_POSITION_CENTER:
     line->allocated_baseline =
line->minimum_above +
(line->allocation - (line->minimum_above + line->minimum_below)) / 2;
     break;
   case CTK_BASELINE_POSITION_BOTTOM:
     line->allocated_baseline =
line->allocation - line->minimum_below;
     break;
   }
}
    else
line->allocated_baseline = -1;
  }
1353}

1355/* Computes the position fields from allocation and spacing.
*/
1357static void
1358ctk_grid_request_position (CtkGridRequest *request,
                         CtkOrientation  orientation)
1360{
CtkGridPrivate *priv = request->grid->priv;
CtkGridLineData *linedata;
CtkGridLines *lines;
CtkGridLine *line;
gint position, old_position;
int allocated_baseline;
gint i, j;

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];

allocated_baseline = ctk_widget_get_allocated_baseline (CTK_WIDGET(request->grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((request->grid)), ((ctk_widget_get_type ())))))));

position = 0;
for (i = 0; i < lines->max - lines->min; i++)
  {
    line = &lines->lines[i];

    if (orientation == CTK_ORIENTATION_VERTICAL &&
 i + lines->min == priv->baseline_row &&
 allocated_baseline != -1 &&
 lines->lines[i].minimum_above != -1)
{
 old_position = position;
 position = allocated_baseline - line->minimum_above;

 /* Back-patch previous rows */
 for (j = 0; j < i; j++)
   {
     if (!lines->lines[j].empty)
lines->lines[j].position += position - old_position;
   }
}

    if (!line->empty)
      {
        line->position = position;
        position += line->allocation + linedata->spacing;

 if (orientation == CTK_ORIENTATION_VERTICAL &&
     i + lines->min == priv->baseline_row &&
     allocated_baseline != -1 &&
     lines->lines[i].minimum_above != -1)
   line->allocated_baseline = allocated_baseline - line->position;
      }
  }
1407}

1409static void
1410ctk_grid_get_size (CtkGrid        *grid,
                 CtkOrientation  orientation,
                 gint           *minimum,
                 gint           *natural,
   gint           *minimum_baseline,
   gint           *natural_baseline)
1416{
CtkGridRequest request;
CtkGridLines *lines;

*minimum = 0;
*natural = 0;

if (minimum_baseline)
  *minimum_baseline = -1;

if (natural_baseline)
  *natural_baseline = -1;

if (grid->priv->children == NULL((void*)0))
  return;

request.grid = grid;
ctk_grid_request_count_lines (&request);
lines = &request.lines[orientation];
lines->lines = g_newa (CtkGridLine, lines->max - lines->min)((CtkGridLine*) __builtin_alloca (sizeof (CtkGridLine) * (gsize
) (lines->max - lines->min)));
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (CtkGridLine));

ctk_grid_request_run (&request, orientation, FALSE(0));
ctk_grid_request_sum (&request, orientation, minimum, natural,
	minimum_baseline, natural_baseline);
1441}

1443static void
1444ctk_grid_get_size_for_size (CtkGrid        *grid,
                          CtkOrientation  orientation,
                          gint            size,
                          gint           *minimum,
                          gint           *natural,
	    gint           *minimum_baseline,
                          gint           *natural_baseline)
1451{
CtkGridRequest request;
CtkGridLines *lines;
gint min_size, nat_size;

*minimum = 0;
*natural = 0;

if (minimum_baseline)
  *minimum_baseline = -1;

if (natural_baseline)
  *natural_baseline = -1;

if (grid->priv->children == NULL((void*)0))
  return;

request.grid = grid;
ctk_grid_request_count_lines (&request);
lines = &request.lines[0];
lines->lines = g_newa (CtkGridLine, lines->max - lines->min)((CtkGridLine*) __builtin_alloca (sizeof (CtkGridLine) * (gsize
) (lines->max - lines->min)));
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (CtkGridLine));
lines = &request.lines[1];
lines->lines = g_newa (CtkGridLine, lines->max - lines->min)((CtkGridLine*) __builtin_alloca (sizeof (CtkGridLine) * (gsize
) (lines->max - lines->min)));
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (CtkGridLine));

ctk_grid_request_run (&request, 1 - orientation, FALSE(0));
ctk_grid_request_sum (&request, 1 - orientation, &min_size, &nat_size, NULL((void*)0), NULL((void*)0));
ctk_grid_request_allocate (&request, 1 - orientation, MAX (size, min_size)(((size) > (min_size)) ? (size) : (min_size)));

ctk_grid_request_run (&request, orientation, TRUE(!(0)));
ctk_grid_request_sum (&request, orientation, minimum, natural, minimum_baseline, natural_baseline);
1483}

1485static void
1486ctk_grid_get_preferred_width (CtkWidget *widget,
                            gint      *minimum,
                            gint      *natural)
1489{
ctk_css_gadget_get_preferred_size (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_HORIZONTAL,
                                   -1,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
1495}

1497static void
1498ctk_grid_get_preferred_height (CtkWidget *widget,
                             gint      *minimum,
                             gint      *natural)
1501{
ctk_css_gadget_get_preferred_size (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   -1,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
1507}

1509static void
1510ctk_grid_get_preferred_width_for_height (CtkWidget *widget,
                                       gint       height,
                                       gint      *minimum,
                                       gint      *natural)
1514{
ctk_css_gadget_get_preferred_size (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_HORIZONTAL,
                                   height,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
1520}

1522static void
1523ctk_grid_get_preferred_height_for_width (CtkWidget *widget,
                                       gint       width,
                                       gint      *minimum,
                                       gint      *natural)
1527{
ctk_css_gadget_get_preferred_size (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   width,
                                   minimum, natural,
                                   NULL((void*)0), NULL((void*)0));
1533}

1535static void
1536ctk_grid_get_preferred_height_and_baseline_for_width (CtkWidget *widget,
				      gint       width,
				      gint      *minimum,
				      gint      *natural,
				      gint      *minimum_baseline,
				      gint      *natural_baseline)
1542{
ctk_css_gadget_get_preferred_size (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget,
                                   CTK_ORIENTATION_VERTICAL,
                                   width,
                                   minimum, natural,
                                   minimum_baseline, natural_baseline);
1548}

1550static void
1551ctk_grid_measure (CtkCssGadget   *gadget,
                CtkOrientation  orientation,
                int             for_size,
                int            *minimum,
                int            *natural,
                int            *minimum_baseline,
                int            *natural_baseline,
                gpointer        data G_GNUC_UNUSED__attribute__ ((__unused__)))
1559{
CtkWidget *widget = ctk_css_gadget_get_owner (gadget);
CtkGrid *grid = CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))));

if ((orientation == CTK_ORIENTATION_HORIZONTAL &&
     ctk_widget_get_request_mode (widget) == CTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT) ||
    (orientation == CTK_ORIENTATION_VERTICAL &&
     ctk_widget_get_request_mode (widget) == CTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH))
  ctk_grid_get_size_for_size (grid, orientation, for_size, minimum, natural, minimum_baseline, natural_baseline);
else
  ctk_grid_get_size (grid, orientation, minimum, natural, minimum_baseline, natural_baseline);
1570}

1572static void
1573allocate_child (CtkGridRequest *request,
              CtkOrientation  orientation,
              CtkGridChild   *child,
              gint           *position,
              gint           *size,
gint           *baseline)
1579{
CtkGridPrivate *priv = request->grid->priv;
CtkGridLineData *linedata;
CtkGridLines *lines;
CtkGridLine *line;
CtkGridChildAttach *attach;
gint i;

linedata = &priv->linedata[orientation];
lines = &request->lines[orientation];
attach = &child->attach[orientation];

*position = lines->lines[attach->pos - lines->min].position;
if (attach->span == 1)
  *baseline = lines->lines[attach->pos - lines->min].allocated_baseline;
else
  *baseline = -1;

*size = (attach->span - 1) * linedata->spacing;
for (i = 0; i < attach->span; i++)
  {
    line = &lines->lines[attach->pos - lines->min + i];
    *size += line->allocation;
  }
1603}

1605static void
1606ctk_grid_request_allocate_children (CtkGridRequest      *request,
                                  const CtkAllocation *allocation)
1608{
CtkGridPrivate *priv = request->grid->priv;
GList *list;
CtkGridChild *child;
CtkAllocation child_allocation;
gint x, y, width, height, baseline, ignore;

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

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

    allocate_child (request, CTK_ORIENTATION_HORIZONTAL, child, &x, &width, &ignore);
    allocate_child (request, CTK_ORIENTATION_VERTICAL, child, &y, &height, &baseline);

    child_allocation.x = allocation->x + x;
    child_allocation.y = allocation->y + y;
    child_allocation.width = MAX (1, width)(((1) > (width)) ? (1) : (width));
    child_allocation.height = MAX (1, height)(((1) > (height)) ? (1) : (height));

    if (ctk_widget_get_direction (CTK_WIDGET (request->grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((request->grid)), ((ctk_widget_get_type ()))))))) == CTK_TEXT_DIR_RTL)
      child_allocation.x = allocation->x + allocation->width
                           - (child_allocation.x - allocation->x) - child_allocation.width;

    ctk_widget_size_allocate_with_baseline (child->widget, &child_allocation, baseline);
  }
1636}

1638#define GET_SIZE(allocation, orientation)(orientation == CTK_ORIENTATION_HORIZONTAL ? allocation->width
 : allocation->height) (orientation == CTK_ORIENTATION_HORIZONTAL ? allocation->width : allocation->height)

1640static void
1641ctk_grid_size_allocate (CtkWidget     *widget,
                      CtkAllocation *allocation)
1643{
CtkAllocation clip;

ctk_widget_set_allocation (widget, allocation);

ctk_css_gadget_allocate (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget,
                         allocation,
                         ctk_widget_get_allocated_baseline (widget),
                         &clip);

ctk_widget_set_clip (widget, &clip);
1654}

1656static void
1657ctk_grid_allocate (CtkCssGadget        *gadget,
                 const CtkAllocation *allocation,
                 int                  baseline G_GNUC_UNUSED__attribute__ ((__unused__)),
                 CtkAllocation       *out_clip,
                 gpointer             data G_GNUC_UNUSED__attribute__ ((__unused__)))
1662{
CtkWidget *widget = ctk_css_gadget_get_owner (gadget);
CtkGrid *grid = CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))));
CtkGridPrivate *priv = grid->priv;
CtkGridRequest request;
CtkGridLines *lines;
CtkOrientation orientation;

if (priv->children == NULL((void*)0))
1
Assuming field 'children' is not equal to NULL→
2
←
Taking false branch→
  return;

request.grid = grid;

ctk_grid_request_count_lines (&request);
lines = &request.lines[0];
lines->lines = g_newa (CtkGridLine, lines->max - lines->min)((CtkGridLine*) __builtin_alloca (sizeof (CtkGridLine) * (gsize
) (lines->max - lines->min)));
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (CtkGridLine));
lines = &request.lines[1];
lines->lines = g_newa (CtkGridLine, lines->max - lines->min)((CtkGridLine*) __builtin_alloca (sizeof (CtkGridLine) * (gsize
) (lines->max - lines->min)));
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (CtkGridLine));

if (ctk_widget_get_request_mode (widget) == CTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT)
3
←
Assuming the condition is false→
4
←
Taking false branch→
  orientation = CTK_ORIENTATION_HORIZONTAL;
else
  orientation = CTK_ORIENTATION_VERTICAL;

ctk_grid_request_run (&request, 1 - orientation, FALSE(0));
ctk_grid_request_allocate (&request, 1 - orientation, GET_SIZE (allocation, 1 - orientation)(1 - orientation == CTK_ORIENTATION_HORIZONTAL ? allocation->
width : allocation->height));
5
←
'?' condition is true→
ctk_grid_request_run (&request, orientation, TRUE(!(0)));

ctk_grid_request_allocate (&request, orientation, GET_SIZE (allocation, orientation)(orientation == CTK_ORIENTATION_HORIZONTAL ? allocation->width
 : allocation->height));
6
←
'?' condition is false→
7
←
Calling 'ctk_grid_request_allocate'→

ctk_grid_request_position (&request, 0);
ctk_grid_request_position (&request, 1);

ctk_grid_request_allocate_children (&request, allocation);

ctk_container_get_children_clip (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))), out_clip);
1700}

1702static gboolean
1703ctk_grid_render (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      data G_GNUC_UNUSED__attribute__ ((__unused__)))
1710{
CTK_WIDGET_CLASS (ctk_grid_parent_class)((((CtkWidgetClass*) (void *) g_type_check_class_cast ((GTypeClass
*) ((ctk_grid_parent_class)), ((ctk_widget_get_type ()))))))->draw (ctk_css_gadget_get_owner (gadget), cr);

return FALSE(0);
1714}

1716static gboolean
1717ctk_grid_draw (CtkWidget *widget,
             cairo_t   *cr)
1719{
ctk_css_gadget_draw (CTK_GRID (widget)((((CtkGrid*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((widget)), ((ctk_grid_get_type ()))))))->priv->gadget, cr);

return FALSE(0);
1723}

1725static void
1726ctk_grid_class_init (CtkGridClass *class)
1727{
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->get_property = ctk_grid_get_property;
object_class->set_property = ctk_grid_set_property;
object_class->finalize = ctk_grid_finalize;

widget_class->size_allocate = ctk_grid_size_allocate;
widget_class->get_preferred_width = ctk_grid_get_preferred_width;
widget_class->get_preferred_height = ctk_grid_get_preferred_height;
widget_class->get_preferred_width_for_height = ctk_grid_get_preferred_width_for_height;
widget_class->get_preferred_height_for_width = ctk_grid_get_preferred_height_for_width;
widget_class->get_preferred_height_and_baseline_for_width = ctk_grid_get_preferred_height_and_baseline_for_width;
widget_class->draw = ctk_grid_draw;

container_class->add = ctk_grid_add;
container_class->remove = ctk_grid_remove;
container_class->forall = ctk_grid_forall;
container_class->child_type = ctk_grid_child_type;
container_class->set_child_property = ctk_grid_set_child_property;
container_class->get_child_property = ctk_grid_get_child_property;
ctk_container_class_handle_border_width (container_class);

g_object_class_override_property (object_class, PROP_ORIENTATION, "orientation");

obj_properties[PROP_ROW_SPACING] =
  g_param_spec_int ("row-spacing",
                    P_("Row spacing")g_dgettext("ctk30" "-properties","Row spacing"),
                    P_("The amount of space between two consecutive rows")g_dgettext("ctk30" "-properties","The amount of space between two consecutive rows"
),
                    0, G_MAXINT16((gint16) 0x7fff), 0,
                    CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

obj_properties[PROP_COLUMN_SPACING] =
  g_param_spec_int ("column-spacing",
                    P_("Column spacing")g_dgettext("ctk30" "-properties","Column spacing"),
                    P_("The amount of space between two consecutive columns")g_dgettext("ctk30" "-properties","The amount of space between two consecutive columns"
),
                    0, G_MAXINT16((gint16) 0x7fff), 0,
                    CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

obj_properties[PROP_ROW_HOMOGENEOUS] =
  g_param_spec_boolean ("row-homogeneous",
                        P_("Row Homogeneous")g_dgettext("ctk30" "-properties","Row Homogeneous"),
                        P_("If TRUE, the rows are all the same height")g_dgettext("ctk30" "-properties","If TRUE, the rows are all the same height"
),
                        FALSE(0),
                        CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

obj_properties[PROP_COLUMN_HOMOGENEOUS] =
  g_param_spec_boolean ("column-homogeneous",
                        P_("Column Homogeneous")g_dgettext("ctk30" "-properties","Column Homogeneous"),
                        P_("If TRUE, the columns are all the same width")g_dgettext("ctk30" "-properties","If TRUE, the columns are all the same width"
),
                        FALSE(0),
                        CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB|G_PARAM_EXPLICIT_NOTIFY);

obj_properties[PROP_BASELINE_ROW] =
  g_param_spec_int ("baseline-row",
                    P_("Baseline Row")g_dgettext("ctk30" "-properties","Baseline Row"),
                    P_("The row to align the to the baseline when valign is CTK_ALIGN_BASELINE")g_dgettext("ctk30" "-properties","The row to align the to the baseline when valign is CTK_ALIGN_BASELINE"
),
                    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);

g_object_class_install_properties (object_class,
                                   N_PROPERTIES,
                                   obj_properties);

child_properties[CHILD_PROP_LEFT_ATTACH] =
  g_param_spec_int ("left-attach",
                    P_("Left attachment")g_dgettext("ctk30" "-properties","Left attachment"),
                    P_("The column number to attach the left side of the child to")g_dgettext("ctk30" "-properties","The column number to attach the left side of the child to"
),
                    G_MININT(-2147483647 -1), G_MAXINT2147483647, 0,
                    CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

child_properties[CHILD_PROP_TOP_ATTACH] =
  g_param_spec_int ("top-attach",
                    P_("Top attachment")g_dgettext("ctk30" "-properties","Top attachment"),
                    P_("The row number to attach the top side of a child widget to")g_dgettext("ctk30" "-properties","The row number to attach the top side of a child widget to"
),
                    G_MININT(-2147483647 -1), G_MAXINT2147483647, 0,
                    CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

child_properties[CHILD_PROP_WIDTH] =
  g_param_spec_int ("width",
                    P_("Width")g_dgettext("ctk30" "-properties","Width"),
                    P_("The number of columns that a child spans")g_dgettext("ctk30" "-properties","The number of columns that a child spans"
),
                    1, G_MAXINT2147483647, 1,
                    CTK_PARAM_READWRITEG_PARAM_READWRITE|G_PARAM_STATIC_NAME|G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB);

child_properties[CHILD_PROP_HEIGHT] =
  g_param_spec_int ("height",
                    P_("Height")g_dgettext("ctk30" "-properties","Height"),
                    P_("The number of rows that a child spans")g_dgettext("ctk30" "-properties","The number of rows that a child spans"
),
                    1, G_MAXINT2147483647, 1,
                    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, N_CHILD_PROPERTIES, child_properties);
ctk_widget_class_set_css_name (widget_class, "grid");
1823}

1825static void
1826ctk_grid_init (CtkGrid *grid)
1827{
CtkGridPrivate *priv;

grid->priv = ctk_grid_get_instance_private (grid);
priv = grid->priv;

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

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

priv->linedata[0].spacing = 0;
priv->linedata[1].spacing = 0;

priv->linedata[0].homogeneous = FALSE(0);
priv->linedata[1].homogeneous = FALSE(0);

priv->gadget = ctk_css_custom_gadget_new_for_node (ctk_widget_get_css_node (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))),
                                                   CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))),
                                                   ctk_grid_measure,
                                                   ctk_grid_allocate,
                                                   ctk_grid_render,
                                                   NULL((void*)0),
                                                   NULL((void*)0));


_ctk_orientable_set_style_classes (CTK_ORIENTABLE (grid)((((CtkOrientable*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_orientable_get_type ())))))));
1855}

1857/**
* ctk_grid_new:
*
* Creates a new grid widget.
*
* Returns: the new #CtkGrid
*/
1864CtkWidget *
1865ctk_grid_new (void)
1866{
return g_object_new (CTK_TYPE_GRID(ctk_grid_get_type ()), NULL((void*)0));
1868}

1870/**
* ctk_grid_attach:
* @grid: a #CtkGrid
* @child: the widget to add
* @left: the column number to attach the left side of @child to
* @top: the row number to attach the top side of @child to
* @width: the number of columns that @child will span
* @height: the number of rows that @child will span
*
* Adds a widget to the grid.
*
* The position of @child is determined by @left and @top. The
* number of “cells” that @child will occupy is determined by
* @width and @height.
*/
1885void
1886ctk_grid_attach (CtkGrid   *grid,
               CtkWidget *child,
               gint       left,
               gint       top,
               gint       width,
               gint       height)
1892{
g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); 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);
g_return_if_fail (_ctk_widget_get_parent (child) == 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; } } while
 (0);
g_return_if_fail (width > 0)do { if ((width > 0)) { } else { g_return_if_fail_warning (
"Ctk", ((const char*) (__func__)), "width > 0"); return; }
 } while (0);
g_return_if_fail (height > 0)do { if ((height > 0)) { } else { g_return_if_fail_warning
 ("Ctk", ((const char*) (__func__)), "height > 0"); return
; } } while (0);

grid_attach (grid, child, left, top, width, height);
1900}

1902/**
* ctk_grid_attach_next_to:
* @grid: a #CtkGrid
* @child: the widget to add
* @sibling: (allow-none): the child of @grid that @child will be placed
*     next to, or %NULL to place @child at the beginning or end
* @side: the side of @sibling that @child is positioned next to
* @width: the number of columns that @child will span
* @height: the number of rows that @child will span
*
* Adds a widget to the grid.
*
* The widget is placed next to @sibling, on the side determined by
* @side. When @sibling is %NULL, the widget is placed in row (for
* left or right placement) or column 0 (for top or bottom placement),
* at the end indicated by @side.
*
* Attaching widgets labeled [1], [2], [3] with @sibling == %NULL and
* @side == %CTK_POS_LEFT yields a layout of [3][2][1].
*/
1922void
1923ctk_grid_attach_next_to (CtkGrid         *grid,
                       CtkWidget       *child,
                       CtkWidget       *sibling,
                       CtkPositionType  side,
                       gint             width,
                       gint             height)
1929{
CtkGridChild *grid_sibling;
gint left, top;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); 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);
g_return_if_fail (_ctk_widget_get_parent (child) == 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; } } while
 (0);
g_return_if_fail (sibling == NULL || _ctk_widget_get_parent (sibling) == (CtkWidget*)grid)do { if ((sibling == ((void*)0) || _ctk_widget_get_parent (sibling
) == (CtkWidget*)grid)) { } else { g_return_if_fail_warning (
"Ctk", ((const char*) (__func__)), "sibling == NULL || _ctk_widget_get_parent (sibling) == (CtkWidget*)grid"
); return; } } while (0);
g_return_if_fail (width > 0)do { if ((width > 0)) { } else { g_return_if_fail_warning (
"Ctk", ((const char*) (__func__)), "width > 0"); return; }
 } while (0);
g_return_if_fail (height > 0)do { if ((height > 0)) { } else { g_return_if_fail_warning
 ("Ctk", ((const char*) (__func__)), "height > 0"); return
; } } while (0);

if (sibling)
  {
    grid_sibling = find_grid_child (grid, sibling);

    switch (side)
      {
      case CTK_POS_LEFT:
        left = CHILD_LEFT (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_HORIZONTAL].pos) - width;
        top = CHILD_TOP (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_VERTICAL].pos);
        break;
      case CTK_POS_RIGHT:
        left = CHILD_LEFT (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_HORIZONTAL].pos) + CHILD_WIDTH (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_HORIZONTAL].span);
        top = CHILD_TOP (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_VERTICAL].pos);
        break;
      case CTK_POS_TOP:
        left = CHILD_LEFT (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_HORIZONTAL].pos);
        top = CHILD_TOP (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_VERTICAL].pos) - height;
        break;
      case CTK_POS_BOTTOM:
        left = CHILD_LEFT (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_HORIZONTAL].pos);
        top = CHILD_TOP (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_VERTICAL].pos) + CHILD_HEIGHT (grid_sibling)((grid_sibling)->attach[CTK_ORIENTATION_VERTICAL].span);
        break;
      default:
        g_assert_not_reached ()do { g_assertion_message_expr ("Ctk", "ctkgrid.c", 1963, ((const
 char*) (__func__)), ((void*)0)); } while (0);
      }
  }
else
  {
    switch (side)
      {
      case CTK_POS_LEFT:
        left = find_attach_position (grid, CTK_ORIENTATION_HORIZONTAL, 0, height, FALSE(0));
        left -= width;
        top = 0;
        break;
      case CTK_POS_RIGHT:
        left = find_attach_position (grid, CTK_ORIENTATION_HORIZONTAL, 0, height, TRUE(!(0)));
        top = 0;
        break;
      case CTK_POS_TOP:
        left = 0;
        top = find_attach_position (grid, CTK_ORIENTATION_VERTICAL, 0, width, FALSE(0));
        top -= height;
        break;
      case CTK_POS_BOTTOM:
        left = 0;
        top = find_attach_position (grid, CTK_ORIENTATION_VERTICAL, 0, width, TRUE(!(0)));
        break;
      default:
        g_assert_not_reached ()do { g_assertion_message_expr ("Ctk", "ctkgrid.c", 1989, ((const
 char*) (__func__)), ((void*)0)); } while (0);
      }
  }

grid_attach (grid, child, left, top, width, height);
1994}

1996/**
* ctk_grid_get_child_at:
* @grid: a #CtkGrid
* @left: the left edge of the cell
* @top: the top edge of the cell
*
* Gets the child of @grid whose area covers the grid
* cell whose upper left corner is at @left, @top.
*
* Returns: (transfer none) (nullable): the child at the given position, or %NULL
*
* Since: 3.2
*/
2009CtkWidget *
2010ctk_grid_get_child_at (CtkGrid *grid,
                     gint     left,
                     gint     top)
2013{
CtkGridPrivate *priv;
CtkGridChild *child;
GList *list;

g_return_val_if_fail (CTK_IS_GRID (grid), NULL)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return (((void*)0)); } } while (0);

priv = grid->priv;

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

    if (CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos) <= left &&
        CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos) + CHILD_WIDTH (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span) > left &&
        CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos) <= top &&
        CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos) + CHILD_HEIGHT (child)((child)->attach[CTK_ORIENTATION_VERTICAL].span) > top)
      return child->widget;
  }

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

2036/**
* ctk_grid_insert_row:
* @grid: a #CtkGrid
* @position: the position to insert the row at
*
* Inserts a row at the specified position.
*
* Children which are attached at or below this position
* are moved one row down. Children which span across this
* position are grown to span the new row.
*
* Since: 3.2
*/
2049void
2050ctk_grid_insert_row (CtkGrid *grid,
                   gint     position)
2052{
CtkGridPrivate *priv;
CtkGridChild *child;
GList *list;
gint top, height;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv = grid->priv;

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

    top = CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos);
    height = CHILD_HEIGHT (child)((child)->attach[CTK_ORIENTATION_VERTICAL].span);

    if (top >= position)
      {
        CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos) = top + 1;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))),
                                             child->widget,
                                             child_properties[CHILD_PROP_TOP_ATTACH]);
      }
    else if (top + height > position)
      {
        CHILD_HEIGHT (child)((child)->attach[CTK_ORIENTATION_VERTICAL].span) = height + 1;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))),
                                             child->widget,
                                             child_properties[CHILD_PROP_HEIGHT]);
      }
  }

for (list = priv->row_properties; list != NULL((void*)0); list = list->next)
  {
    CtkGridRowProperties *prop = list->data;

    if (prop->row >= position)
prop->row += 1;
  }
2092}

2094/**
* ctk_grid_remove_row:
* @grid: a #CtkGrid
* @position: the position of the row to remove
*
* Removes a row from the grid.
*
* Children that are placed in this row are removed,
* spanning children that overlap this row have their
* height reduced by one, and children below the row
* are moved up.
*
* Since: 3.10
*/
2108void
2109ctk_grid_remove_row (CtkGrid *grid,
                   gint     position)
2111{
CtkGridPrivate *priv;
CtkGridChild *child;
GList *list;
gint top, height;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv = grid->priv;

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

    top = CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos);
    height = CHILD_HEIGHT (child)((child)->attach[CTK_ORIENTATION_VERTICAL].span);

    if (top <= position && top + height > position)
      height--;
    if (top > position)
      top--;

    if (height <= 0)
      ctk_container_remove (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))), child->widget);
    else
      ctk_container_child_set (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))), child->widget,
                               "height", height,
                               "top-attach", top,
                               NULL((void*)0));
  }
2143}

2145/**
* ctk_grid_insert_column:
* @grid: a #CtkGrid
* @position: the position to insert the column at
*
* Inserts a column at the specified position.
*
* Children which are attached at or to the right of this position
* are moved one column to the right. Children which span across this
* position are grown to span the new column.
*
* Since: 3.2
*/
2158void
2159ctk_grid_insert_column (CtkGrid *grid,
                      gint     position)
2161{
CtkGridPrivate *priv;
CtkGridChild *child;
GList *list;
gint left, width;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv = grid->priv;

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

    left = CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos);
    width = CHILD_WIDTH (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span);

    if (left >= position)
      {
        CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos) = left + 1;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))),
                                             child->widget,
                                             child_properties[CHILD_PROP_LEFT_ATTACH]);
      }
    else if (left + width > position)
      {
        CHILD_WIDTH (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span) = width + 1;
        ctk_container_child_notify_by_pspec (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))),
                                             child->widget,
                                             child_properties[CHILD_PROP_WIDTH]);
      }
  }
2193}

2195/**
* ctk_grid_remove_column:
* @grid: a #CtkGrid
* @position: the position of the column to remove
*
* Removes a column from the grid.
*
* Children that are placed in this column are removed,
* spanning children that overlap this column have their
* width reduced by one, and children after the column
* are moved to the left.
*
* Since: 3.10
*/
2209void
2210ctk_grid_remove_column (CtkGrid *grid,
                      gint     position)
2212{
CtkGridPrivate *priv;
CtkGridChild *child;
GList *list;
gint left, width;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv = grid->priv;

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

    left = CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos);
    width = CHILD_WIDTH (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span);

    if (left <= position && left + width > position)
      width--;
    if (left > position)
      left--;

    if (width <= 0)
      ctk_container_remove (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))), child->widget);
    else
      ctk_container_child_set (CTK_CONTAINER (grid)((((CtkContainer*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_container_get_type ())))))), child->widget,
                               "width", width,
                               "left-attach", left,
                               NULL((void*)0));
  }
2244}

2246/**
* ctk_grid_insert_next_to:
* @grid: a #CtkGrid
* @sibling: the child of @grid that the new row or column will be
*     placed next to
* @side: the side of @sibling that @child is positioned next to
*
* Inserts a row or column at the specified position.
*
* The new row or column is placed next to @sibling, on the side
* determined by @side. If @side is %CTK_POS_TOP or %CTK_POS_BOTTOM,
* a row is inserted. If @side is %CTK_POS_LEFT of %CTK_POS_RIGHT,
* a column is inserted.
*
* Since: 3.2
*/
2262void
2263ctk_grid_insert_next_to (CtkGrid         *grid,
                       CtkWidget       *sibling,
                       CtkPositionType  side)
2266{
CtkGridChild *child;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);
g_return_if_fail (CTK_IS_WIDGET (sibling))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((sibling)); 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 (sibling)"); return; } } while (0);
g_return_if_fail (_ctk_widget_get_parent (sibling) == (CtkWidget*)grid)do { if ((_ctk_widget_get_parent (sibling) == (CtkWidget*)grid
)) { } else { g_return_if_fail_warning ("Ctk", ((const char*)
 (__func__)), "_ctk_widget_get_parent (sibling) == (CtkWidget*)grid"
); return; } } while (0);

child = find_grid_child (grid, sibling);

switch (side)
  {
  case CTK_POS_LEFT:
    ctk_grid_insert_column (grid, CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos));
    break;
  case CTK_POS_RIGHT:
    ctk_grid_insert_column (grid, CHILD_LEFT (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].pos) + CHILD_WIDTH (child)((child)->attach[CTK_ORIENTATION_HORIZONTAL].span));
    break;
  case CTK_POS_TOP:
    ctk_grid_insert_row (grid, CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos));
    break;
  case CTK_POS_BOTTOM:
    ctk_grid_insert_row (grid, CHILD_TOP (child)((child)->attach[CTK_ORIENTATION_VERTICAL].pos) + CHILD_HEIGHT (child)((child)->attach[CTK_ORIENTATION_VERTICAL].span));
    break;
  default:
    g_assert_not_reached ()do { g_assertion_message_expr ("Ctk", "ctkgrid.c", 2290, ((const
 char*) (__func__)), ((void*)0)); } while (0);
  }
2292}

2294/**
* ctk_grid_set_row_homogeneous:
* @grid: a #CtkGrid
* @homogeneous: %TRUE to make rows homogeneous
*
* Sets whether all rows of @grid will have the same height.
*/
2301void
2302ctk_grid_set_row_homogeneous (CtkGrid  *grid,
                            gboolean  homogeneous)
2304{
CtkGridPrivate *priv;
g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv = grid->priv;

/* Yes, homogeneous rows means all the columns have the same size */
if (COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->homogeneous != homogeneous)
  {
    COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->homogeneous = homogeneous;

    if (_ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
      ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));

    g_object_notify_by_pspec (G_OBJECT (grid)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), (((GType) ((20) << (2)))))))), obj_properties [PROP_ROW_HOMOGENEOUS]);
  }
2320}

2322/**
* ctk_grid_get_row_homogeneous:
* @grid: a #CtkGrid
*
* Returns whether all rows of @grid have the same height.
*
* Returns: whether all rows of @grid have the same height.
*/
2330gboolean
2331ctk_grid_get_row_homogeneous (CtkGrid *grid)
2332{
CtkGridPrivate *priv;
g_return_val_if_fail (CTK_IS_GRID (grid), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return ((0)); } } while (0);

priv = grid->priv;

return COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->homogeneous;
2339}

2341/**
* ctk_grid_set_column_homogeneous:
* @grid: a #CtkGrid
* @homogeneous: %TRUE to make columns homogeneous
*
* Sets whether all columns of @grid will have the same width.
*/
2348void
2349ctk_grid_set_column_homogeneous (CtkGrid  *grid,
                               gboolean  homogeneous)
2351{
CtkGridPrivate *priv;
g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv = grid->priv;

/* Yes, homogeneous columns means all the rows have the same size */
if (ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->homogeneous != homogeneous)
  {
    ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->homogeneous = homogeneous;

    if (_ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
      ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));

    g_object_notify_by_pspec (G_OBJECT (grid)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), (((GType) ((20) << (2)))))))), obj_properties [PROP_COLUMN_HOMOGENEOUS]);
  }
2367}

2369/**
* ctk_grid_get_column_homogeneous:
* @grid: a #CtkGrid
*
* Returns whether all columns of @grid have the same width.
*
* Returns: whether all columns of @grid have the same width.
*/
2377gboolean
2378ctk_grid_get_column_homogeneous (CtkGrid *grid)
2379{
CtkGridPrivate *priv;
g_return_val_if_fail (CTK_IS_GRID (grid), FALSE)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return ((0)); } } while (0);

priv = grid->priv;

return ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->homogeneous;
2386}

2388/**
* ctk_grid_set_row_spacing:
* @grid: a #CtkGrid
* @spacing: the amount of space to insert between rows
*
* Sets the amount of space between rows of @grid.
*/
2395void
2396ctk_grid_set_row_spacing (CtkGrid *grid,
                        guint    spacing)
2398{
CtkGridPrivate *priv;
g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);
g_return_if_fail (spacing <= G_MAXINT16)do { if ((spacing <= ((gint16) 0x7fff))) { } else { g_return_if_fail_warning
 ("Ctk", ((const char*) (__func__)), "spacing <= G_MAXINT16"
); return; } } while (0);

priv = grid->priv;

if (COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->spacing != spacing)
  {
    COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->spacing = spacing;

    if (_ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
      ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));

    g_object_notify_by_pspec (G_OBJECT (grid)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), (((GType) ((20) << (2)))))))), obj_properties [PROP_ROW_SPACING]);
  }
2414}

2416/**
* ctk_grid_get_row_spacing:
* @grid: a #CtkGrid
*
* Returns the amount of space between the rows of @grid.
*
* Returns: the row spacing of @grid
*/
2424guint
2425ctk_grid_get_row_spacing (CtkGrid *grid)
2426{
CtkGridPrivate *priv;
g_return_val_if_fail (CTK_IS_GRID (grid), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return (0); } } while (0);

priv = grid->priv;

return COLUMNS (priv)(&(priv)->linedata[CTK_ORIENTATION_VERTICAL])->spacing;
2433}

2435/**
* ctk_grid_set_column_spacing:
* @grid: a #CtkGrid
* @spacing: the amount of space to insert between columns
*
* Sets the amount of space between columns of @grid.
*/
2442void
2443ctk_grid_set_column_spacing (CtkGrid *grid,
                           guint    spacing)
2445{
CtkGridPrivate *priv;
g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);
g_return_if_fail (spacing <= G_MAXINT16)do { if ((spacing <= ((gint16) 0x7fff))) { } else { g_return_if_fail_warning
 ("Ctk", ((const char*) (__func__)), "spacing <= G_MAXINT16"
); return; } } while (0);

priv = grid->priv;

if (ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->spacing != spacing)
  {
    ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->spacing = spacing;

    if (_ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
      ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));

    g_object_notify_by_pspec (G_OBJECT (grid)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), (((GType) ((20) << (2)))))))), obj_properties [PROP_COLUMN_SPACING]);
  }
2461}

2463/**
* ctk_grid_get_column_spacing:
* @grid: a #CtkGrid
*
* Returns the amount of space between the columns of @grid.
*
* Returns: the column spacing of @grid
*/
2471guint
2472ctk_grid_get_column_spacing (CtkGrid *grid)
2473{
CtkGridPrivate *priv;

g_return_val_if_fail (CTK_IS_GRID (grid), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return (0); } } while (0);

priv = grid->priv;

return ROWS (priv)(&(priv)->linedata[CTK_ORIENTATION_HORIZONTAL])->spacing;
2481}

2483static CtkGridRowProperties *
2484find_row_properties (CtkGrid      *grid,
     gint          row)
2486{
GList *l;

for (l = grid->priv->row_properties; l != NULL((void*)0); l = l->next)
  {
    CtkGridRowProperties *prop = l->data;
    if (prop->row == row)
return prop;
  }

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

2499static void
2500ctk_grid_row_properties_free (CtkGridRowProperties *props)
2501{
g_slice_free (CtkGridRowProperties, props)do { if (1) g_slice_free1 (sizeof (CtkGridRowProperties), (props
)); else (void) ((CtkGridRowProperties*) 0 == (props)); } while
 (0);
2503}

2505static CtkGridRowProperties *
2506get_row_properties_or_create (CtkGrid      *grid,
	      gint          row)
2508{
CtkGridRowProperties *props;
CtkGridPrivate *priv = grid->priv;

props = find_row_properties (grid, row);
if (props)
  return props;

props = g_slice_new (CtkGridRowProperties)((CtkGridRowProperties*) g_slice_alloc (sizeof (CtkGridRowProperties
)));
*props = ctk_grid_row_properties_default;
props->row = row;

priv->row_properties =
  g_list_prepend (priv->row_properties, props);

return props;
2524}

2526static const CtkGridRowProperties *
2527get_row_properties_or_default (CtkGrid      *grid,
	       gint          row)
2529{
CtkGridRowProperties *props;

props = find_row_properties (grid, row);
if (props)
  return props;
return &ctk_grid_row_properties_default;
2536}

2538/**
* ctk_grid_set_row_baseline_position:
* @grid: a #CtkGrid
* @row: a row index
* @pos: a #CtkBaselinePosition
*
* Sets how the baseline should be positioned on @row of the
* grid, in case that row is assigned more space than is requested.
*
* Since: 3.10
*/
2549void
2550ctk_grid_set_row_baseline_position (CtkGrid            *grid,
		    gint                row,
		    CtkBaselinePosition pos)
2553{
CtkGridRowProperties *props;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

props = get_row_properties_or_create (grid, row);

if (props->baseline_position != pos)
  {
    props->baseline_position = pos;

    if (_ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
      ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));
  }
2567}

2569/**
* ctk_grid_get_row_baseline_position:
* @grid: a #CtkGrid
* @row: a row index
*
* Returns the baseline position of @row as set
* by ctk_grid_set_row_baseline_position() or the default value
* %CTK_BASELINE_POSITION_CENTER.
*
* Returns: the baseline position of @row
*
* Since: 3.10
*/
2582CtkBaselinePosition
2583ctk_grid_get_row_baseline_position (CtkGrid      *grid,
		    gint          row)
2585{
const CtkGridRowProperties *props;

g_return_val_if_fail (CTK_IS_GRID (grid), CTK_BASELINE_POSITION_CENTER)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return (CTK_BASELINE_POSITION_CENTER
); } } while (0);

props = get_row_properties_or_default (grid, row);

return props->baseline_position;
2593}

2595/**
* ctk_grid_set_baseline_row:
* @grid: a #CtkGrid
* @row: the row index
*
* Sets which row defines the global baseline for the entire grid.
* Each row in the grid can have its own local baseline, but only
* one of those is global, meaning it will be the baseline in the
* parent of the @grid.
*
* Since: 3.10
*/
2607void
2608ctk_grid_set_baseline_row (CtkGrid *grid,
	   gint     row)
2610{
CtkGridPrivate *priv;

g_return_if_fail (CTK_IS_GRID (grid))do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return; } } while (0);

priv =  grid->priv;

if (priv->baseline_row != row)
  {
    priv->baseline_row = row;

    if (_ctk_widget_get_visible (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ()))))))))
ctk_widget_queue_resize (CTK_WIDGET (grid)((((CtkWidget*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), ((ctk_widget_get_type ())))))));
    g_object_notify (G_OBJECT (grid)((((GObject*) (void *) g_type_check_instance_cast ((GTypeInstance
*) ((grid)), (((GType) ((20) << (2)))))))), "baseline-row");
  }
2625}

2627/**
* ctk_grid_get_baseline_row:
* @grid: a #CtkGrid
*
* Returns which row defines the global baseline of @grid.
*
* Returns: the row index defining the global baseline
*
* Since: 3.10
*/
2637gint
2638ctk_grid_get_baseline_row (CtkGrid *grid)
2639{
CtkGridPrivate *priv;

g_return_val_if_fail (CTK_IS_GRID (grid), 0)do { if (((((__extension__ ({ GTypeInstance *__inst = (GTypeInstance
*) ((grid)); GType __t = ((ctk_grid_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_GRID (grid)"); return (0); } } while (0);

priv = grid->priv;

return priv->baseline_row;
2647}