jean
/
Learning_GTK4_tree
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Learning_GTK4_tree/gtk/gtkgridlayout.c

2036 lines
58 KiB
C
Raw Blame History

/* gtkgridlayout.c: Layout manager for grid-like widgets
* Copyright 2019 GNOME Foundation
*
* SPDX-License-Identifier: LGPL-2.1-or-later
*
* 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.1 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/>.
*/
/**
* GtkGridLayout:
*
* `GtkGridLayout` is a layout manager which arranges child widgets in
* rows and columns.
*
* Children have an "attach point" defined by the horizontal and vertical
* index of the cell they occupy; children can span multiple rows or columns.
* The layout properties for setting the attach points and spans are set
* using the [class@Gtk.GridLayoutChild] associated to each child widget.
*
* The behaviour of `GtkGridLayout` when several children occupy the same
* grid cell is undefined.
*
* `GtkGridLayout` can be used like a `GtkBoxLayout` if all children are
* attached to the same row or column; however, if you only ever need a
* single row or column, you should consider using `GtkBoxLayout`.
*/
/**
* GtkGridLayoutChild:
*
* `GtkLayoutChild` subclass for children in a `GtkGridLayout`.
*/
#include "config.h"
#include "gtkgridlayout.h"
#include "gtkcsspositionvalueprivate.h"
#include "gtkdebug.h"
#include "gtklayoutchild.h"
#include "gtkorientable.h"
#include "gtkprivate.h"
#include "gtksizerequest.h"
#include "gtkwidgetprivate.h"
#include "gtkcssnodeprivate.h"
/* {{{ GtkGridLayoutChild */
typedef struct {
int pos;
int span;
} GridChildAttach;
struct _GtkGridLayoutChild
{
GtkLayoutChild parent_instance;
GridChildAttach attach[2];
};
#define CHILD_COLUMN(child) ((child)->attach[GTK_ORIENTATION_HORIZONTAL].pos)
#define CHILD_COL_SPAN(child) ((child)->attach[GTK_ORIENTATION_HORIZONTAL].span)
#define CHILD_ROW(child) ((child)->attach[GTK_ORIENTATION_VERTICAL].pos)
#define CHILD_ROW_SPAN(child) ((child)->attach[GTK_ORIENTATION_VERTICAL].span)
enum {
PROP_CHILD_COLUMN = 1,
PROP_CHILD_ROW,
PROP_CHILD_COLUMN_SPAN,
PROP_CHILD_ROW_SPAN,
N_CHILD_PROPERTIES
};
static GParamSpec *child_props[N_CHILD_PROPERTIES];
G_DEFINE_TYPE (GtkGridLayoutChild, gtk_grid_layout_child, GTK_TYPE_LAYOUT_CHILD)
static void
gtk_grid_layout_child_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkGridLayoutChild *self = GTK_GRID_LAYOUT_CHILD (gobject);
switch (prop_id)
{
case PROP_CHILD_COLUMN:
gtk_grid_layout_child_set_column (self, g_value_get_int (value));
break;
case PROP_CHILD_ROW :
gtk_grid_layout_child_set_row (self, g_value_get_int (value));
break;
case PROP_CHILD_COLUMN_SPAN:
gtk_grid_layout_child_set_column_span (self, g_value_get_int (value));
break;
case PROP_CHILD_ROW_SPAN:
gtk_grid_layout_child_set_row_span (self, g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
gtk_grid_layout_child_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkGridLayoutChild *self = GTK_GRID_LAYOUT_CHILD (gobject);
switch (prop_id)
{
case PROP_CHILD_COLUMN:
g_value_set_int (value, CHILD_COLUMN (self));
break;
case PROP_CHILD_ROW:
g_value_set_int (value, CHILD_ROW (self));
break;
case PROP_CHILD_COLUMN_SPAN:
g_value_set_int (value, CHILD_COL_SPAN (self));
break;
case PROP_CHILD_ROW_SPAN:
g_value_set_int (value, CHILD_ROW_SPAN (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
gtk_grid_layout_child_class_init (GtkGridLayoutChildClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
gobject_class->set_property = gtk_grid_layout_child_set_property;
gobject_class->get_property = gtk_grid_layout_child_get_property;
/**
* GtkGridLayoutChild:column: (attributes org.gtk.Property.get=gtk_grid_layout_child_get_column org.gtk.Property.set=gtk_grid_layout_child_set_column)
*
* The column to place the child in.
*/
child_props[PROP_CHILD_COLUMN] =
g_param_spec_int ("column", NULL, NULL,
G_MININT, G_MAXINT, 0,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayoutChild:row: (attributes org.gtk.Property.get=gtk_grid_layout_child_get_row org.gtk.Property.set=gtk_grid_layout_child_set_row)
*
* The row to place the child in.
*/
child_props[PROP_CHILD_ROW] =
g_param_spec_int ("row", NULL, NULL,
G_MININT, G_MAXINT, 0,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayoutChild:column-span: (attributes org.gtk.Property.get=gtk_grid_layout_child_get_column_span org.gtk.Property.set=gtk_grid_layout_child_set_column_span)
*
* The number of columns the child spans to.
*/
child_props[PROP_CHILD_COLUMN_SPAN] =
g_param_spec_int ("column-span", NULL, NULL,
1, G_MAXINT, 1,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayoutChild:row-span: (attributes org.gtk.Property.get=gtk_grid_layout_child_get_row_span org.gtk.Property.set=gtk_grid_layout_child_set_row_span)
*
* The number of rows the child spans to.
*/
child_props[PROP_CHILD_ROW_SPAN] =
g_param_spec_int ("row-span", NULL, NULL,
1, G_MAXINT, 1,
GTK_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
g_object_class_install_properties (gobject_class, N_CHILD_PROPERTIES, child_props);
}
static void
gtk_grid_layout_child_init (GtkGridLayoutChild *self)
{
CHILD_ROW_SPAN (self) = 1;
CHILD_COL_SPAN (self) = 1;
}
/**
* gtk_grid_layout_child_set_row: (attributes org.gtk.Method.set_property=row)
* @child: a `GtkGridLayoutChild`
* @row: the row for @child
*
* Sets the row to place @child in.
*/
void
gtk_grid_layout_child_set_row (GtkGridLayoutChild *child,
int row)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child));
if (CHILD_ROW (child) == row)
return;
CHILD_ROW (child) = row;
gtk_layout_manager_layout_changed (gtk_layout_child_get_layout_manager (GTK_LAYOUT_CHILD (child)));
g_object_notify_by_pspec (G_OBJECT (child), child_props[PROP_CHILD_ROW]);
}
/**
* gtk_grid_layout_child_get_row: (attributes org.gtk.Method.get_property=row)
* @child: a `GtkGridLayoutChild`
*
* Retrieves the row number to which @child attaches its top side.
*
* Returns: the row number
*/
int
gtk_grid_layout_child_get_row (GtkGridLayoutChild *child)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child), 0);
return CHILD_ROW (child);
}
/**
* gtk_grid_layout_child_set_column: (attributes org.gtk.Method.set_property=column)
* @child: a `GtkGridLayoutChild`
* @column: the attach point for @child
*
* Sets the column number to attach the left side of @child.
*/
void
gtk_grid_layout_child_set_column (GtkGridLayoutChild *child,
int column)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child));
if (CHILD_COLUMN (child) == column)
return;
CHILD_COLUMN (child) = column;
gtk_layout_manager_layout_changed (gtk_layout_child_get_layout_manager (GTK_LAYOUT_CHILD (child)));
g_object_notify_by_pspec (G_OBJECT (child), child_props[PROP_CHILD_COLUMN]);
}
/**
* gtk_grid_layout_child_get_column: (attributes org.gtk.Method.get_property=column)
* @child: a `GtkGridLayoutChild`
*
* Retrieves the column number to which @child attaches its left side.
*
* Returns: the column number
*/
int
gtk_grid_layout_child_get_column (GtkGridLayoutChild *child)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child), 0);
return CHILD_COLUMN (child);
}
/**
* gtk_grid_layout_child_set_column_span: (attributes org.gtk.Method.set_property=column-span)
* @child: a `GtkGridLayoutChild`
* @span: the span of @child
*
* Sets the number of columns @child spans to.
*/
void
gtk_grid_layout_child_set_column_span (GtkGridLayoutChild *child,
int span)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child));
if (CHILD_COL_SPAN (child) == span)
return;
CHILD_COL_SPAN (child) = span;
gtk_layout_manager_layout_changed (gtk_layout_child_get_layout_manager (GTK_LAYOUT_CHILD (child)));
g_object_notify_by_pspec (G_OBJECT (child), child_props[PROP_CHILD_COLUMN_SPAN]);
}
/**
* gtk_grid_layout_child_get_column_span: (attributes org.gtk.Method.get_property=column-span)
* @child: a `GtkGridLayoutChild`
*
* Retrieves the number of columns that @child spans to.
*
* Returns: the number of columns
*/
int
gtk_grid_layout_child_get_column_span (GtkGridLayoutChild *child)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child), 1);
return CHILD_COL_SPAN (child);
}
/**
* gtk_grid_layout_child_set_row_span: (attributes org.gtk.Method.set_property=row-span)
* @child: a `GtkGridLayoutChild`
* @span: the span of @child
*
* Sets the number of rows @child spans to.
*/
void
gtk_grid_layout_child_set_row_span (GtkGridLayoutChild *child,
int span)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child));
if (CHILD_ROW_SPAN (child) == span)
return;
CHILD_ROW_SPAN (child) = span;
gtk_layout_manager_layout_changed (gtk_layout_child_get_layout_manager (GTK_LAYOUT_CHILD (child)));
g_object_notify_by_pspec (G_OBJECT (child), child_props[PROP_CHILD_ROW_SPAN]);
}
/**
* gtk_grid_layout_child_get_row_span: (attributes org.gtk.Method.get_property=row-span)
* @child: a `GtkGridLayoutChild`
*
* Retrieves the number of rows that @child spans to.
*
* Returns: the number of row
*/
int
gtk_grid_layout_child_get_row_span (GtkGridLayoutChild *child)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT_CHILD (child), 1);
return CHILD_ROW_SPAN (child);
}
/* }}} */
/* {{{ GtkGridLayout */
typedef struct {
int row;
GtkBaselinePosition baseline_position;
} GridRowProperties;
static const GridRowProperties grid_row_properties_default = {
0,
GTK_BASELINE_POSITION_CENTER
};
/* A GridLineData struct contains row/column specific parts
* of the grid.
*/
typedef struct {
gint16 spacing;
guint homogeneous : 1;
} GridLineData;
#define ROWS(layout) (&(layout)->linedata[GTK_ORIENTATION_HORIZONTAL])
#define COLUMNS(layout) (&(layout)->linedata[GTK_ORIENTATION_VERTICAL])
/* A GridLine struct represents a single row or column
* during size requests
*/
typedef struct {
int minimum;
int natural;
int minimum_above;
int minimum_below;
int natural_above;
int natural_below;
int position;
int allocation;
int allocated_baseline;
guint need_expand : 1;
guint expand : 1;
guint empty : 1;
} GridLine;
typedef struct {
GridLine *lines;
int min, max;
} GridLines;
typedef struct {
GtkGridLayout *layout;
GtkWidget *widget;
GridLines lines[2];
} GridRequest;
struct _GtkGridLayout
{
GtkLayoutManager parent_instance;
/* Array<GridRowProperties> */
GArray *row_properties;
GtkOrientation orientation;
int baseline_row;
GridLineData linedata[2];
};
enum {
PROP_ROW_SPACING = 1,
PROP_COLUMN_SPACING,
PROP_ROW_HOMOGENEOUS,
PROP_COLUMN_HOMOGENEOUS,
PROP_BASELINE_ROW,
N_PROPERTIES
};
static GParamSpec *layout_props[N_PROPERTIES];
G_DEFINE_TYPE (GtkGridLayout, gtk_grid_layout, GTK_TYPE_LAYOUT_MANAGER)
static inline GtkGridLayoutChild *
get_grid_child (GtkGridLayout *self,
GtkWidget *child)
{
GtkLayoutManager *manager = GTK_LAYOUT_MANAGER (self);
return (GtkGridLayoutChild *) gtk_layout_manager_get_layout_child (manager, child);
}
static int
get_spacing (GtkGridLayout *self,
GtkWidget *widget,
GtkOrientation orientation)
{
GtkCssNode *node = gtk_widget_get_css_node (widget);
GtkCssStyle *style = gtk_css_node_get_style (node);
GtkCssValue *border_spacing;
int css_spacing;
border_spacing = style->size->border_spacing;
if (orientation == GTK_ORIENTATION_HORIZONTAL)
css_spacing = _gtk_css_position_value_get_x (border_spacing, 100);
else
css_spacing = _gtk_css_position_value_get_y (border_spacing, 100);
return css_spacing + self->linedata[orientation].spacing;
}
/* Calculates the min and max numbers for both orientations. */
static void
grid_request_count_lines (GridRequest *request)
{
GtkWidget *child;
int min[2];
int max[2];
min[0] = min[1] = G_MAXINT;
max[0] = max[1] = G_MININT;
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
GridChildAttach *attach = grid_child->attach;
min[0] = MIN (min[0], attach[0].pos);
max[0] = MAX (max[0], attach[0].pos + attach[0].span);
min[1] = MIN (min[1], attach[1].pos);
max[1] = MAX (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];
}
/* Sets line sizes to 0 and marks lines as expand
* if they have a non-spanning expanding child.
*/
static void
grid_request_init (GridRequest *request,
GtkOrientation orientation)
{
GtkWidget *child;
GridLines *lines;
int 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;
lines->lines[i].empty = TRUE;
}
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
GridChildAttach *attach;
attach = &grid_child->attach[orientation];
if (attach->span == 1 && gtk_widget_compute_expand (child, orientation))
lines->lines[attach->pos - lines->min].expand = TRUE;
}
}
/* Sums allocations for lines spanned by child and their spacing.
*/
static int
compute_allocation_for_child (GridRequest *request,
GtkGridLayoutChild *child,
GtkOrientation orientation)
{
GridLines *lines;
GridLine *line;
GridChildAttach *attach;
int size;
int i;
lines = &request->lines[orientation];
attach = &child->attach[orientation];
size = (attach->span - 1) * get_spacing (request->layout, request->widget, orientation);
for (i = 0; i < attach->span; i++)
{
line = &lines->lines[attach->pos - lines->min + i];
size += line->allocation;
}
return size;
}
static void
compute_request_for_child (GridRequest *request,
GtkWidget *child,
GtkGridLayoutChild *grid_child,
GtkOrientation orientation,
gboolean contextual,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
if (minimum_baseline != NULL)
*minimum_baseline = -1;
if (natural_baseline != NULL)
*natural_baseline = -1;
if (contextual)
{
int size;
size = compute_allocation_for_child (request, grid_child, 1 - orientation);
gtk_widget_measure (child,
orientation,
size,
minimum, natural,
minimum_baseline, natural_baseline);
}
else
{
gtk_widget_measure (child,
orientation,
-1,
minimum, natural,
minimum_baseline, natural_baseline);
}
}
/* Sets requisition to max. of non-spanning children.
* If contextual is TRUE, requires allocations of
* lines in the opposite orientation to be set.
*/
static void
grid_request_non_spanning (GridRequest *request,
GtkOrientation orientation,
gboolean contextual)
{
GtkWidget *child;
GridLines *lines;
GridLine *line;
int i;
GtkBaselinePosition baseline_pos;
int minimum, minimum_baseline;
int natural, natural_baseline;
lines = &request->lines[orientation];
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
GridChildAttach *attach;
if (!gtk_widget_should_layout (child))
continue;
attach = &grid_child->attach[orientation];
if (attach->span != 1)
continue;
compute_request_for_child (request, child, grid_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_below = MAX (line->minimum_below, minimum - minimum_baseline);
line->natural_above = MAX (line->natural_above, natural_baseline);
line->natural_below = MAX (line->natural_below, natural - natural_baseline);
}
else
{
line->minimum = MAX (line->minimum, minimum);
line->natural = MAX (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->natural = MAX (line->natural, line->natural_above + line->natural_below);
baseline_pos = gtk_grid_layout_get_row_baseline_position (request->layout, i + lines->min);
switch (baseline_pos)
{
case GTK_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 GTK_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 GTK_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;
default:
break;
}
}
}
}
/* Enforce homogeneous sizes */
static void
grid_request_homogeneous (GridRequest *request,
GtkOrientation orientation)
{
GtkGridLayout *self = request->layout;
GridLineData *linedata;
GridLines *lines;
int minimum, natural;
int i;
linedata = &self->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);
natural = MAX (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 homogeneous resize.
*/
}
}
/* Deals with spanning children.
* Requires expand fields of lines to be set for
* non-spanning children.
*/
static void
grid_request_spanning (GridRequest *request,
GtkOrientation orientation,
gboolean contextual)
{
GtkGridLayout *self = request->layout;
GtkWidget *child;
GridChildAttach *attach;
GridLineData *linedata;
GridLines *lines;
GridLine *line;
int minimum, natural;
int span_minimum, span_natural;
int span_expand;
gboolean force_expand;
int spacing;
int extra;
int expand;
int line_extra;
int i;
linedata = &self->linedata[orientation];
lines = &request->lines[orientation];
spacing = get_spacing (request->layout, request->widget, orientation);
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
if (!gtk_widget_should_layout (child))
continue;
attach = &grid_child->attach[orientation];
if (attach->span == 1)
continue;
/* We ignore baselines for spanning children */
compute_request_for_child (request, child, grid_child, orientation, contextual, &minimum, &natural, NULL, NULL);
span_minimum = (attach->span - 1) * spacing;
span_natural = (attach->span - 1) * spacing;
span_expand = 0;
force_expand = FALSE;
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;
}
/* 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)
{
int total, m;
total = minimum - (attach->span - 1) * 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);
}
}
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)
{
int total, n;
total = natural - (attach->span - 1) * 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);
}
}
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;
}
}
}
}
}
}
/* Marks empty and expanding lines and counts them */
static void
grid_request_compute_expand (GridRequest *request,
GtkOrientation orientation,
int min,
int max,
int *nonempty_lines,
int *expand_lines)
{
GtkWidget *child;
GridChildAttach *attach;
int i;
GridLines *lines;
GridLine *line;
gboolean has_expand;
int expand;
int empty;
lines = &request->lines[orientation];
min = MAX (min, lines->min);
max = MIN (max, lines->max);
for (i = min - lines->min; i < max - lines->min; i++)
{
lines->lines[i].need_expand = FALSE;
lines->lines[i].expand = FALSE;
lines->lines[i].empty = TRUE;
}
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
if (!gtk_widget_should_layout (child))
continue;
attach = &grid_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;
if (gtk_widget_compute_expand (child, orientation))
line->expand = TRUE;
}
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
if (!gtk_widget_should_layout (child))
continue;
attach = &grid_child->attach[orientation];
if (attach->span == 1)
continue;
has_expand = FALSE;
for (i = 0; i < attach->span; i++)
{
line = &lines->lines[attach->pos - lines->min + i];
if (line->expand)
has_expand = TRUE;
if (attach->pos + i >= max || attach->pos + 1 < min)
continue;
line->empty = FALSE;
}
if (!has_expand && gtk_widget_compute_expand (child, 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;
}
}
}
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;
if (line->empty)
empty += 1;
if (line->expand)
expand += 1;
}
if (nonempty_lines)
*nonempty_lines = max - min - empty;
if (expand_lines)
*expand_lines = expand;
}
/* Sums the minimum and natural fields of lines and their spacing */
static void
grid_request_sum (GridRequest *request,
GtkOrientation orientation,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GtkGridLayout *self = request->layout;
GridLines *lines;
int i;
int min, nat;
int nonempty;
int spacing;
grid_request_compute_expand (request, orientation, G_MININT, G_MAXINT, &nonempty, NULL);
lines = &request->lines[orientation];
spacing = get_spacing (request->layout, request->widget, orientation);
min = 0;
nat = 0;
for (i = 0; i < lines->max - lines->min; i++)
{
if (orientation == GTK_ORIENTATION_VERTICAL &&
lines->min + i == self->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 += spacing;
nat += spacing;
}
}
/* Remove last spacing, if any was applied */
if (nonempty > 0)
{
min -= spacing;
nat -= spacing;
}
*minimum = min;
*natural = nat;
}
/* Computes minimum and natural fields of lines.
* When contextual is TRUE, requires allocation of
* lines in the opposite orientation to be set.
*/
static void
grid_request_run (GridRequest *request,
GtkOrientation orientation,
gboolean contextual)
{
grid_request_init (request, orientation);
grid_request_non_spanning (request, orientation, contextual);
grid_request_homogeneous (request, orientation);
grid_request_spanning (request, orientation, contextual);
grid_request_homogeneous (request, orientation);
}
static void
grid_distribute_non_homogeneous (GridLines *lines,
int nonempty,
int expand,
int size,
int min,
int max)
{
GtkRequestedSize *sizes;
GridLine *line;
int extra;
int rest;
int i, j;
if (nonempty == 0)
return;
sizes = g_newa (GtkRequestedSize, 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 = gtk_distribute_natural_allocation (MAX (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);
line->allocation = sizes[j].minimum_size;
if (line->expand)
{
line->allocation += extra;
if (rest > 0)
{
line->allocation += 1;
rest -= 1;
}
}
j++;
}
}
/* Requires that the minimum and natural fields of lines
* have been set, computes the allocation field of lines
* by distributing total_size among lines.
*/
static void
grid_request_allocate (GridRequest *request,
GtkOrientation orientation,
int total_size)
{
GtkGridLayout *self = request->layout;
GridLineData *linedata;
GridLines *lines;
GridLine *line;
int nonempty1, nonempty2;
int expand1, expand2;
int i;
GtkBaselinePosition baseline_pos;
int baseline;
int extra, extra2;
int rest;
int size1, size2;
int split, split_pos;
int spacing;
linedata = &self->linedata[orientation];
lines = &request->lines[orientation];
spacing = get_spacing (request->layout, request->widget, orientation);
baseline = gtk_widget_get_baseline (request->widget);
if (orientation == GTK_ORIENTATION_VERTICAL && baseline != -1 &&
self->baseline_row >= lines->min && self->baseline_row < lines->max &&
lines->lines[self->baseline_row - lines->min].minimum_above != -1)
{
split = self->baseline_row;
split_pos = baseline - lines->lines[self->baseline_row - lines->min].minimum_above;
grid_request_compute_expand (request, orientation, lines->min, split, &nonempty1, &expand1);
grid_request_compute_expand (request, orientation, split, lines->max, &nonempty2, &expand2);
if (nonempty2 > 0)
{
size1 = split_pos - (nonempty1) * spacing;
size2 = (total_size - split_pos) - (nonempty2 - 1) * spacing;
}
else
{
size1 = total_size - (nonempty1 - 1) * spacing;
size2 = 0;
}
}
else
{
grid_request_compute_expand (request, orientation, lines->min, lines->max, &nonempty1, &expand1);
nonempty2 = expand2 = 0;
split = lines->max;
size1 = total_size - (nonempty1 - 1) * 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
{
grid_distribute_non_homogeneous (lines,
nonempty1,
expand1,
size1,
lines->min,
split);
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 grid_request_position for the allocated baseline */
baseline_pos = gtk_grid_layout_get_row_baseline_position (request->layout, i + lines->min);
switch (baseline_pos)
{
case GTK_BASELINE_POSITION_TOP:
line->allocated_baseline = line->minimum_above;
break;
case GTK_BASELINE_POSITION_CENTER:
line->allocated_baseline = line->minimum_above +
(line->allocation - (line->minimum_above + line->minimum_below)) / 2;
break;
case GTK_BASELINE_POSITION_BOTTOM:
line->allocated_baseline = line->allocation - line->minimum_below;
break;
default:
break;
}
}
else
line->allocated_baseline = -1;
}
}
/* Computes the position fields from allocation and spacing */
static void
grid_request_position (GridRequest *request,
GtkOrientation orientation)
{
GtkGridLayout *self = request->layout;
GridLines *lines;
GridLine *line;
int position, old_position;
int allocated_baseline;
int spacing;
int i, j;
lines = &request->lines[orientation];
spacing = get_spacing (request->layout, request->widget, orientation);
allocated_baseline = gtk_widget_get_baseline (request->widget);
position = 0;
for (i = 0; i < lines->max - lines->min; i++)
{
line = &lines->lines[i];
if (orientation == GTK_ORIENTATION_VERTICAL &&
i + lines->min == self->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 + spacing;
if (orientation == GTK_ORIENTATION_VERTICAL &&
i + lines->min == self->baseline_row &&
allocated_baseline != -1 &&
lines->lines[i].minimum_above != -1)
line->allocated_baseline = allocated_baseline - line->position;
}
}
}
static void
gtk_grid_layout_get_size (GtkGridLayout *self,
GtkWidget *widget,
GtkOrientation orientation,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GridRequest request;
GridLines *lines;
*minimum = 0;
*natural = 0;
if (minimum_baseline)
*minimum_baseline = -1;
if (natural_baseline)
*natural_baseline = -1;
if (_gtk_widget_get_first_child (widget) == NULL)
return;
request.layout = self;
request.widget = widget;
grid_request_count_lines (&request);
lines = &request.lines[orientation];
lines->lines = g_newa (GridLine, lines->max - lines->min);
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (GridLine));
grid_request_run (&request, orientation, FALSE);
grid_request_sum (&request, orientation,
minimum, natural,
minimum_baseline, natural_baseline);
}
static void
gtk_grid_layout_get_size_for_size (GtkGridLayout *self,
GtkWidget *widget,
GtkOrientation orientation,
int size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GridRequest request;
GridLines *lines;
int min_size, nat_size;
*minimum = 0;
*natural = 0;
if (minimum_baseline)
*minimum_baseline = -1;
if (natural_baseline)
*natural_baseline = -1;
if (_gtk_widget_get_first_child (widget) == NULL)
return;
request.layout = self;
request.widget = widget;
grid_request_count_lines (&request);
lines = &request.lines[0];
lines->lines = g_newa (GridLine, lines->max - lines->min);
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (GridLine));
lines = &request.lines[1];
lines->lines = g_newa (GridLine, lines->max - lines->min);
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (GridLine));
grid_request_run (&request, 1 - orientation, FALSE);
grid_request_sum (&request, 1 - orientation, &min_size, &nat_size, NULL, NULL);
grid_request_allocate (&request, 1 - orientation, MAX (size, min_size));
grid_request_run (&request, orientation, TRUE);
grid_request_sum (&request, orientation,
minimum, natural,
minimum_baseline, natural_baseline);
}
static void
gtk_grid_layout_measure (GtkLayoutManager *manager,
GtkWidget *widget,
GtkOrientation orientation,
int for_size,
int *minimum,
int *natural,
int *minimum_baseline,
int *natural_baseline)
{
GtkGridLayout *self = GTK_GRID_LAYOUT (manager);
if ((orientation == GTK_ORIENTATION_HORIZONTAL &&
gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT) ||
(orientation == GTK_ORIENTATION_VERTICAL &&
gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH))
gtk_grid_layout_get_size_for_size (self, widget, orientation, for_size,
minimum, natural,
minimum_baseline, natural_baseline);
else
gtk_grid_layout_get_size (self, widget, orientation,
minimum, natural,
minimum_baseline, natural_baseline);
}
static void
allocate_child (GridRequest *request,
GtkOrientation orientation,
GtkWidget *child,
GtkGridLayoutChild *grid_child,
int *position,
int *size,
int *baseline)
{
GridLines *lines;
GridLine *line;
GridChildAttach *attach;
int i;
lines = &request->lines[orientation];
attach = &grid_child->attach[orientation];
*position = lines->lines[attach->pos - lines->min].position;
if (attach->span == 1 &&
(gtk_widget_get_valign (child) == GTK_ALIGN_BASELINE_CENTER ||
gtk_widget_get_valign (child) == GTK_ALIGN_BASELINE_FILL))
*baseline = lines->lines[attach->pos - lines->min].allocated_baseline;
else
*baseline = -1;
*size = (attach->span - 1) * get_spacing (request->layout, request->widget, orientation);
for (i = 0; i < attach->span; i++)
{
line = &lines->lines[attach->pos - lines->min + i];
*size += line->allocation;
}
}
static void
grid_request_allocate_children (GridRequest *request,
int grid_width,
int grid_height)
{
GtkWidget *child;
GtkAllocation child_allocation;
int x, y, width, height, baseline, ignore;
for (child = _gtk_widget_get_first_child (request->widget);
child != NULL;
child = _gtk_widget_get_next_sibling (child))
{
GtkGridLayoutChild *grid_child = get_grid_child (request->layout, child);
if (!gtk_widget_should_layout (child))
continue;
allocate_child (request, GTK_ORIENTATION_HORIZONTAL, child, grid_child, &x, &width, &ignore);
allocate_child (request, GTK_ORIENTATION_VERTICAL, child, grid_child, &y, &height, &baseline);
child_allocation.x = x;
child_allocation.y = y;
child_allocation.width = width;
child_allocation.height = height;
if (_gtk_widget_get_direction (request->widget) == GTK_TEXT_DIR_RTL)
child_allocation.x = grid_width - child_allocation.x - child_allocation.width;
gtk_widget_size_allocate (child, &child_allocation, baseline);
}
}
#define GET_SIZE(width, height, orientation) (orientation == GTK_ORIENTATION_HORIZONTAL ? width : height)
static void
gtk_grid_layout_allocate (GtkLayoutManager *manager,
GtkWidget *widget,
int width,
int height,
int baseline)
{
GtkGridLayout *self = GTK_GRID_LAYOUT (manager);
GridRequest request;
GridLines *lines;
GtkOrientation orientation;
if (_gtk_widget_get_first_child (widget) == NULL)
return;
request.layout = self;
request.widget = widget;
grid_request_count_lines (&request);
lines = &request.lines[0];
lines->lines = g_newa (GridLine, lines->max - lines->min);
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (GridLine));
lines = &request.lines[1];
lines->lines = g_newa (GridLine, lines->max - lines->min);
memset (lines->lines, 0, (lines->max - lines->min) * sizeof (GridLine));
if (gtk_widget_get_request_mode (widget) == GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT)
orientation = GTK_ORIENTATION_HORIZONTAL;
else
orientation = GTK_ORIENTATION_VERTICAL;
grid_request_run (&request, OPPOSITE_ORIENTATION (orientation), FALSE);
grid_request_allocate (&request, OPPOSITE_ORIENTATION (orientation),
GET_SIZE (width, height, OPPOSITE_ORIENTATION (orientation)));
grid_request_run (&request, orientation, TRUE);
grid_request_allocate (&request, orientation, GET_SIZE (width, height, orientation));
grid_request_position (&request, 0);
grid_request_position (&request, 1);
grid_request_allocate_children (&request, width, height);
}
static void
gtk_grid_layout_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkGridLayout *self = GTK_GRID_LAYOUT (gobject);
switch (prop_id)
{
case PROP_ROW_SPACING:
gtk_grid_layout_set_row_spacing (self, g_value_get_int (value));
break;
case PROP_COLUMN_SPACING:
gtk_grid_layout_set_column_spacing (self, g_value_get_int (value));
break;
case PROP_ROW_HOMOGENEOUS:
gtk_grid_layout_set_row_homogeneous (self, g_value_get_boolean (value));
break;
case PROP_COLUMN_HOMOGENEOUS:
gtk_grid_layout_set_column_homogeneous (self, g_value_get_boolean (value));
break;
case PROP_BASELINE_ROW:
gtk_grid_layout_set_baseline_row (self, g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
gtk_grid_layout_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkGridLayout *self = GTK_GRID_LAYOUT (gobject);
switch (prop_id)
{
case PROP_ROW_SPACING:
g_value_set_int (value, COLUMNS (self)->spacing);
break;
case PROP_COLUMN_SPACING:
g_value_set_int (value, ROWS (self)->spacing);
break;
case PROP_ROW_HOMOGENEOUS:
g_value_set_boolean (value, COLUMNS (self)->homogeneous);
break;
case PROP_COLUMN_HOMOGENEOUS:
g_value_set_boolean (value, ROWS (self)->homogeneous);
break;
case PROP_BASELINE_ROW:
g_value_set_int (value, self->baseline_row);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
gtk_grid_layout_finalize (GObject *gobject)
{
GtkGridLayout *self = GTK_GRID_LAYOUT (gobject);
g_clear_pointer (&self->row_properties, g_array_unref);
G_OBJECT_CLASS (gtk_grid_layout_parent_class)->finalize (gobject);
}
static void
gtk_grid_layout_class_init (GtkGridLayoutClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GtkLayoutManagerClass *layout_class = GTK_LAYOUT_MANAGER_CLASS (klass);
layout_class->layout_child_type = GTK_TYPE_GRID_LAYOUT_CHILD;
layout_class->measure = gtk_grid_layout_measure;
layout_class->allocate = gtk_grid_layout_allocate;
gobject_class->set_property = gtk_grid_layout_set_property;
gobject_class->get_property = gtk_grid_layout_get_property;
gobject_class->finalize = gtk_grid_layout_finalize;
/**
* GtkGridLayout:row-spacing: (attributes org.gtk.Property.get=gtk_grid_layout_get_row_spacing org.gtk.Property.set=gtk_grid_layout_set_row_spacing)
*
* The amount of space between to consecutive rows.
*/
layout_props[PROP_ROW_SPACING] =
g_param_spec_int ("row-spacing", NULL, NULL,
0, G_MAXINT16, 0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayout:column-spacing: (attributes org.gtk.Property.get=gtk_grid_layout_get_column_spacing org.gtk.Property.set=gtk_grid_layout_set_column_spacing)
*
* The amount of space between to consecutive columns.
*/
layout_props[PROP_COLUMN_SPACING] =
g_param_spec_int ("column-spacing", NULL, NULL,
0, G_MAXINT16, 0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayout:row-homogeneous: (attributes org.gtk.Property.get=gtk_grid_layout_get_row_homogeneous org.gtk.Property.set=gtk_grid_layout_set_row_homogeneous)
*
* Whether all the rows in the grid have the same height.
*/
layout_props[PROP_ROW_HOMOGENEOUS] =
g_param_spec_boolean ("row-homogeneous", NULL, NULL,
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayout:column-homogeneous: (attributes org.gtk.Property.get=gtk_grid_layout_get_column_homogeneous org.gtk.Property.set=gtk_grid_layout_set_column_homogeneous)
*
* Whether all the columns in the grid have the same width.
*/
layout_props[PROP_COLUMN_HOMOGENEOUS] =
g_param_spec_boolean ("column-homogeneous", NULL, NULL,
FALSE,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
/**
* GtkGridLayout:baseline-row: (attributes org.gtk.Property.get=gtk_grid_layout_get_baseline_row org.gtk.Property.set=gtk_grid_layout_set_baseline_row)
*
* The row to align to the baseline, when `GtkWidget:valign` is set
* to %GTK_ALIGN_BASELINE.
*/
layout_props[PROP_BASELINE_ROW] =
g_param_spec_int ("baseline-row", NULL, NULL,
0, G_MAXINT, 0,
GTK_PARAM_READWRITE|G_PARAM_EXPLICIT_NOTIFY);
g_object_class_install_properties (gobject_class, N_PROPERTIES, layout_props);
}
static void
gtk_grid_layout_init (GtkGridLayout *self)
{
}
/**
* gtk_grid_layout_new:
*
* Creates a new `GtkGridLayout`.
*
* Returns: the newly created `GtkGridLayout`
*/
GtkLayoutManager *
gtk_grid_layout_new (void)
{
return g_object_new (GTK_TYPE_GRID_LAYOUT, NULL);
}
/**
* gtk_grid_layout_set_row_homogeneous: (attributes org.gtk.Method.set_property=row-homogeneous)
* @grid: a `GtkGridLayout`
* @homogeneous: %TRUE to make rows homogeneous
*
* Sets whether all rows of @grid should have the same height.
*/
void
gtk_grid_layout_set_row_homogeneous (GtkGridLayout *grid,
gboolean homogeneous)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT (grid));
/* Yes, homogeneous rows means all the columns have the same size */
if (COLUMNS (grid)->homogeneous == !!homogeneous)
return;
COLUMNS (grid)->homogeneous = !!homogeneous;
gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (grid));
g_object_notify_by_pspec (G_OBJECT (grid), layout_props[PROP_ROW_HOMOGENEOUS]);
}
/**
* gtk_grid_layout_get_row_homogeneous: (attributes org.gtk.Method.get_property=row-homogeneous)
* @grid: a `GtkGridLayout`
*
* Checks whether all rows of @grid should have the same height.
*
* Returns: %TRUE if the rows are homogeneous, and %FALSE otherwise
*/
gboolean
gtk_grid_layout_get_row_homogeneous (GtkGridLayout *grid)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT (grid), FALSE);
return COLUMNS (grid)->homogeneous;
}
/**
* gtk_grid_layout_set_row_spacing: (attributes org.gtk.Method.set_property=row-spacing)
* @grid: a `GtkGridLayout`
* @spacing: the amount of space between rows, in pixels
*
* Sets the amount of space to insert between consecutive rows.
*/
void
gtk_grid_layout_set_row_spacing (GtkGridLayout *grid,
guint spacing)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT (grid));
g_return_if_fail (spacing <= G_MAXINT16);
if (COLUMNS (grid)->spacing == spacing)
return;
COLUMNS (grid)->spacing = spacing;
gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (grid));
g_object_notify_by_pspec (G_OBJECT (grid), layout_props[PROP_ROW_SPACING]);
}
/**
* gtk_grid_layout_get_row_spacing: (attributes org.gtk.Method.get_property=row-spacing)
* @grid: a `GtkGridLayout`
*
* Retrieves the spacing set with gtk_grid_layout_set_row_spacing().
*
* Returns: the spacing between consecutive rows
*/
guint
gtk_grid_layout_get_row_spacing (GtkGridLayout *grid)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT (grid), 0);
return COLUMNS (grid)->spacing;
}
/**
* gtk_grid_layout_set_column_homogeneous: (attributes org.gtk.Method.set_property=column-homogeneous)
* @grid: a `GtkGridLayout`
* @homogeneous: %TRUE to make columns homogeneous
*
* Sets whether all columns of @grid should have the same width.
*/
void
gtk_grid_layout_set_column_homogeneous (GtkGridLayout *grid,
gboolean homogeneous)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT (grid));
/* Yes, homogeneous columns means all the rows have the same size */
if (ROWS (grid)->homogeneous == !!homogeneous)
return;
ROWS (grid)->homogeneous = !!homogeneous;
gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (grid));
g_object_notify_by_pspec (G_OBJECT (grid), layout_props[PROP_COLUMN_HOMOGENEOUS]);
}
/**
* gtk_grid_layout_get_column_homogeneous: (attributes org.gtk.Method.get_property=column-homogeneous)
* @grid: a `GtkGridLayout`
*
* Checks whether all columns of @grid should have the same width.
*
* Returns: %TRUE if the columns are homogeneous, and %FALSE otherwise
*/
gboolean
gtk_grid_layout_get_column_homogeneous (GtkGridLayout *grid)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT (grid), FALSE);
return ROWS (grid)->homogeneous;
}
/**
* gtk_grid_layout_set_column_spacing: (attributes org.gtk.Method.set_property=column-spacing)
* @grid: a `GtkGridLayout`
* @spacing: the amount of space between columns, in pixels
*
* Sets the amount of space to insert between consecutive columns.
*/
void
gtk_grid_layout_set_column_spacing (GtkGridLayout *grid,
guint spacing)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT (grid));
g_return_if_fail (spacing <= G_MAXINT16);
if (ROWS (grid)->spacing == spacing)
return;
ROWS (grid)->spacing = spacing;
gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (grid));
g_object_notify_by_pspec (G_OBJECT (grid), layout_props[PROP_COLUMN_SPACING]);
}
/**
* gtk_grid_layout_get_column_spacing: (attributes org.gtk.Method.get_property=column-spacing)
* @grid: a `GtkGridLayout`
*
* Retrieves the spacing set with gtk_grid_layout_set_column_spacing().
*
* Returns: the spacing between consecutive columns
*/
guint
gtk_grid_layout_get_column_spacing (GtkGridLayout *grid)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT (grid), 0);
return ROWS (grid)->spacing;
}
static GridRowProperties *
find_row_properties (GtkGridLayout *self,
int row)
{
int i;
if (self->row_properties == NULL)
return NULL;
for (i = 0; i < self->row_properties->len; i++)
{
GridRowProperties *prop = &g_array_index (self->row_properties, GridRowProperties, i);
if (prop->row == row)
return prop;
}
return NULL;
}
static GridRowProperties *
get_row_properties_or_create (GtkGridLayout *self,
int row)
{
GridRowProperties *props;
props = find_row_properties (self, row);
if (props != NULL)
return props;
/* This is the only place where we create the row properties array;
* find_row_properties() is used by getters, so we should not create
* the array there.
*/
if (self->row_properties == NULL)
self->row_properties = g_array_new (FALSE, FALSE, sizeof (GridRowProperties));
g_array_append_vals (self->row_properties, &grid_row_properties_default, 1);
props = &g_array_index (self->row_properties, GridRowProperties, self->row_properties->len - 1);
props->row = row;
return props;
}
static const GridRowProperties *
get_row_properties_or_default (GtkGridLayout *self,
int row)
{
GridRowProperties *props;
props = find_row_properties (self, row);
if (props != NULL)
return props;
return &grid_row_properties_default;
}
/**
* gtk_grid_layout_set_row_baseline_position:
* @grid: a `GtkGridLayout`
* @row: a row index
* @pos: a `GtkBaselinePosition`
*
* Sets how the baseline should be positioned on @row of the
* grid, in case that row is assigned more space than is requested.
*/
void
gtk_grid_layout_set_row_baseline_position (GtkGridLayout *grid,
int row,
GtkBaselinePosition pos)
{
GridRowProperties *props;
g_return_if_fail (GTK_IS_GRID_LAYOUT (grid));
props = get_row_properties_or_create (grid, row);
if (props->baseline_position == pos)
return;
props->baseline_position = pos;
gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (grid));
}
/**
* gtk_grid_layout_get_row_baseline_position:
* @grid: a `GtkGridLayout`
* @row: a row index
*
* Returns the baseline position of @row.
*
* If no value has been set with
* [method@Gtk.GridLayout.set_row_baseline_position],
* the default value of %GTK_BASELINE_POSITION_CENTER
* is returned.
*
* Returns: the baseline position of @row
*/
GtkBaselinePosition
gtk_grid_layout_get_row_baseline_position (GtkGridLayout *grid,
int row)
{
const GridRowProperties *props;
g_return_val_if_fail (GTK_IS_GRID_LAYOUT (grid), GTK_BASELINE_POSITION_CENTER);
props = get_row_properties_or_default (grid, row);
return props->baseline_position;
}
/**
* gtk_grid_layout_set_baseline_row: (attributes org.gtk.Method.set_property=baseline-row)
* @grid: a `GtkGridLayout`
* @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.
*/
void
gtk_grid_layout_set_baseline_row (GtkGridLayout *grid,
int row)
{
g_return_if_fail (GTK_IS_GRID_LAYOUT (grid));
if (grid->baseline_row == row)
return;
grid->baseline_row = row;
gtk_layout_manager_layout_changed (GTK_LAYOUT_MANAGER (grid));
g_object_notify_by_pspec (G_OBJECT (grid), layout_props[PROP_BASELINE_ROW]);
}
/**
* gtk_grid_layout_get_baseline_row: (attributes org.gtk.Method.get_property=baseline-row)
* @grid: a `GtkGridLayout`
*
* Retrieves the row set with gtk_grid_layout_set_baseline_row().
*
* Returns: the global baseline row
*/
int
gtk_grid_layout_get_baseline_row (GtkGridLayout *grid)
{
g_return_val_if_fail (GTK_IS_GRID_LAYOUT (grid), GTK_BASELINE_POSITION_CENTER);
return grid->baseline_row;
}
/* }}} */
Reference in New Issue View Git Blame Copy Permalink