isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-10 07:56:14 -05:00
Code Issues Packages Projects Releases Wiki Activity
397f322860
mutter/clutter/clutter-table-layout.c
Emmanuele Bassi bca93c1a75 Deprecate ClutterAlpha 
It's time. Now that we have clutter_actor_allocate() respecting the
easing state of an actor, and that the LayoutManager animation virtual
functions have been deprecated, we can put ClutterAlpha on the chopping
block, and be done with it, once and for all.

So long, ClutterAlpha; and thanks for all the fish.
2012-04-27 12:30:50 +01:00

2562 lines
73 KiB
C
Raw Blame History

/*
* Clutter.
*
* An OpenGL based 'interactive canvas' library.
*
* Copyright (C) 2009 Intel Corporation.
*
* 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/>.
*
* Author:
* Jose Dapena Paz <jdapena@igalia.com>
*
* Based on the MX MxTable actor by:
* Thomas Wood <thomas.wood@intel.com>
* and ClutterBoxLayout by:
* Emmanuele Bassi <ebassi@linux.intel.com>
*/
/**
* SECTION:clutter-table-layout
* @title: ClutterTableLayout
* @short_description: A layout manager arranging children in rows
* and columns
*
* The #ClutterTableLayout is a #ClutterLayoutManager implementing the
* following layout policy:
*
* <itemizedlist>
* <listitem><para>children are arranged in a table</para></listitem>
* <listitem><para>each child specifies the specific row and column
* cell to appear;</para></listitem>
* <listitem><para>a child can also set a span, and this way, take
* more than one cell both horizontally and vertically;</para></listitem>
* <listitem><para>each child will be allocated to its natural
* size or, if set to expand, the available size;</para></listitem>
* <listitem><para>if a child is set to fill on either (or both)
* axis, its allocation will match all the available size; the
* fill layout property only makes sense if the expand property is
* also set;</para></listitem>
* <listitem><para>if a child is set to expand but not to fill then
* it is possible to control the alignment using the horizontal and
* vertical alignment layout properties.</para></listitem>
* </itemizedlist>
*
* It is possible to control the spacing between children of a
* #ClutterTableLayout by using clutter_table_layout_set_row_spacing()
* and clutter_table_layout_set_column_spacing().
*
* In order to set the layout properties when packing an actor inside a
* #ClutterTableLayout you should use the clutter_table_layout_pack()
* function.
*
* A #ClutterTableLayout can use animations to transition between different
* values of the layout management properties; the easing mode and duration
* used for the animations are controlled by the
* #ClutterTableLayout:easing-mode and #ClutterTableLayout:easing-duration
* properties and their accessor functions.
*
* <figure id="table-layout-image">
* <title>Table layout</title>
* <para>The image shows a #ClutterTableLayout.</para>
* <graphic fileref="table-layout.png" format="PNG"/>
* </figure>
*
* #ClutterTableLayout is available since Clutter 1.4
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <math.h>
#define CLUTTER_DISABLE_DEPRECATION_WARNINGS
#include "deprecated/clutter-container.h"
#include "deprecated/clutter-alpha.h"
#include "clutter-table-layout.h"
#include "clutter-debug.h"
#include "clutter-enum-types.h"
#include "clutter-layout-meta.h"
#include "clutter-private.h"
#include "clutter-types.h"
#define CLUTTER_TYPE_TABLE_CHILD (clutter_table_child_get_type ())
#define CLUTTER_TABLE_CHILD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), CLUTTER_TYPE_TABLE_CHILD, ClutterTableChild))
#define CLUTTER_IS_TABLE_CHILD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), CLUTTER_TYPE_TABLE_CHILD))
#define CLUTTER_TABLE_LAYOUT_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), CLUTTER_TYPE_TABLE_LAYOUT, ClutterTableLayoutPrivate))
typedef struct _ClutterTableChild ClutterTableChild;
typedef struct _ClutterLayoutMetaClass ClutterTableChildClass;
typedef struct _DimensionData {
gfloat min_size;
gfloat pref_size;
gfloat final_size;
guint expand : 1;
guint visible : 1;
} DimensionData;
struct _ClutterTableLayoutPrivate
{
ClutterContainer *container;
guint col_spacing;
guint row_spacing;
gint n_rows;
gint n_cols;
gint active_row;
gint active_col;
gint visible_rows;
gint visible_cols;
GArray *columns;
GArray *rows;
gulong easing_mode;
guint easing_duration;
guint is_animating : 1;
guint use_animations : 1;
};
struct _ClutterTableChild
{
ClutterLayoutMeta parent_instance;
/* the last stable allocation before an animation; it is used as the
* initial ActorBox when interpolating. If has_last_allocation is
* FALSE then this value is not yet known
*/
ClutterActorBox last_allocation;
gint col;
gint row;
gint col_span;
gint row_span;
ClutterTableAlignment x_align;
ClutterTableAlignment y_align;
guint x_expand : 1;
guint y_expand : 1;
guint x_fill : 1;
guint y_fill : 1;
guint has_last_allocation : 1;
};
enum
{
PROP_CHILD_0,
PROP_CHILD_ROW,
PROP_CHILD_COLUMN,
PROP_CHILD_ROW_SPAN,
PROP_CHILD_COLUMN_SPAN,
PROP_CHILD_X_ALIGN,
PROP_CHILD_Y_ALIGN,
PROP_CHILD_X_FILL,
PROP_CHILD_Y_FILL,
PROP_CHILD_X_EXPAND,
PROP_CHILD_Y_EXPAND
};
enum
{
PROP_0,
PROP_ROW_SPACING,
PROP_COLUMN_SPACING,
PROP_USE_ANIMATIONS,
PROP_EASING_MODE,
PROP_EASING_DURATION
};
GType clutter_table_child_get_type (void);
G_DEFINE_TYPE (ClutterTableChild,
clutter_table_child,
CLUTTER_TYPE_LAYOUT_META);
G_DEFINE_TYPE (ClutterTableLayout,
clutter_table_layout,
CLUTTER_TYPE_LAYOUT_MANAGER);
/*
* ClutterBoxChild
*/
static void
table_child_set_position (ClutterTableChild *self,
gint col,
gint row)
{
gboolean row_changed = FALSE, col_changed = FALSE;
if (self->col != col)
{
self->col = col;
col_changed = TRUE;
}
if (self->row != row)
{
self->row = row;
row_changed = TRUE;
}
if (row_changed || col_changed)
{
ClutterLayoutManager *layout;
layout = clutter_layout_meta_get_manager (CLUTTER_LAYOUT_META (self));
clutter_layout_manager_layout_changed (layout);
g_object_freeze_notify (G_OBJECT (self));
if (row_changed)
g_object_notify (G_OBJECT (self), "row");
if (col_changed)
g_object_notify (G_OBJECT (self), "column");
g_object_thaw_notify (G_OBJECT (self));
}
}
static void
table_child_set_span (ClutterTableChild *self,
gint col_span,
gint row_span)
{
gboolean row_changed = FALSE, col_changed = FALSE;
if (self->col_span != col_span)
{
self->col_span = col_span;
col_changed = TRUE;
}
if (self->row_span != row_span)
{
self->row_span = row_span;
row_changed = TRUE;
}
if (row_changed || col_changed)
{
ClutterLayoutManager *layout;
layout = clutter_layout_meta_get_manager (CLUTTER_LAYOUT_META (self));
clutter_layout_manager_layout_changed (layout);
if (row_changed)
g_object_notify (G_OBJECT (self), "row-span");
if (col_changed)
g_object_notify (G_OBJECT (self), "column-span");
}
}
static void
table_child_set_align (ClutterTableChild *self,
ClutterTableAlignment x_align,
ClutterTableAlignment y_align)
{
gboolean x_changed = FALSE, y_changed = FALSE;
if (self->x_align != x_align)
{
self->x_align = x_align;
x_changed = TRUE;
}
if (self->y_align != y_align)
{
self->y_align = y_align;
y_changed = TRUE;
}
if (x_changed || y_changed)
{
ClutterLayoutManager *layout;
layout = clutter_layout_meta_get_manager (CLUTTER_LAYOUT_META (self));
clutter_layout_manager_layout_changed (layout);
g_object_freeze_notify (G_OBJECT (self));
if (x_changed)
g_object_notify (G_OBJECT (self), "x-align");
if (y_changed)
g_object_notify (G_OBJECT (self), "y-align");
g_object_thaw_notify (G_OBJECT (self));
}
}
static void
table_child_set_fill (ClutterTableChild *self,
gboolean x_fill,
gboolean y_fill)
{
gboolean x_changed = FALSE, y_changed = FALSE;
x_fill = !!x_fill;
y_fill = !!y_fill;
if (self->x_fill != x_fill)
{
self->x_fill = x_fill;
x_changed = TRUE;
}
if (self->y_fill != y_fill)
{
self->y_fill = y_fill;
y_changed = TRUE;
}
if (x_changed || y_changed)
{
ClutterLayoutManager *layout;
layout = clutter_layout_meta_get_manager (CLUTTER_LAYOUT_META (self));
clutter_layout_manager_layout_changed (layout);
g_object_freeze_notify (G_OBJECT (self));
if (x_changed)
g_object_notify (G_OBJECT (self), "x-fill");
if (y_changed)
g_object_notify (G_OBJECT (self), "y-fill");
g_object_thaw_notify (G_OBJECT (self));
}
}
static void
table_child_set_expand (ClutterTableChild *self,
gboolean x_expand,
gboolean y_expand)
{
gboolean x_changed = FALSE, y_changed = FALSE;
x_expand = !!x_expand;
y_expand = !!y_expand;
if (self->x_expand != x_expand)
{
self->x_expand = x_expand;
x_changed = TRUE;
}
if (self->y_expand != y_expand)
{
self->y_expand = y_expand;
y_changed = TRUE;
}
if (x_changed || y_changed)
{
ClutterLayoutManager *layout;
layout = clutter_layout_meta_get_manager (CLUTTER_LAYOUT_META (self));
clutter_layout_manager_layout_changed (layout);
g_object_freeze_notify (G_OBJECT (self));
if (x_changed)
g_object_notify (G_OBJECT (self), "x-expand");
if (y_changed)
g_object_notify (G_OBJECT (self), "y-expand");
g_object_thaw_notify (G_OBJECT (self));
}
}
static void
clutter_table_child_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterTableChild *self = CLUTTER_TABLE_CHILD (gobject);
switch (prop_id)
{
case PROP_CHILD_COLUMN:
table_child_set_position (self,
g_value_get_int (value),
self->row);
break;
case PROP_CHILD_ROW:
table_child_set_position (self,
self->col,
g_value_get_int (value));
break;
case PROP_CHILD_COLUMN_SPAN:
table_child_set_span (self,
g_value_get_int (value),
self->row_span);
break;
case PROP_CHILD_ROW_SPAN:
table_child_set_span (self,
self->col_span,
g_value_get_int (value));
break;
case PROP_CHILD_X_ALIGN:
table_child_set_align (self,
g_value_get_enum (value),
self->y_align);
break;
case PROP_CHILD_Y_ALIGN:
table_child_set_align (self,
self->x_align,
g_value_get_enum (value));
break;
case PROP_CHILD_X_FILL:
table_child_set_fill (self,
g_value_get_boolean (value),
self->y_fill);
break;
case PROP_CHILD_Y_FILL:
table_child_set_fill (self,
self->x_fill,
g_value_get_boolean (value));
break;
case PROP_CHILD_X_EXPAND:
table_child_set_expand (self,
g_value_get_boolean (value),
self->y_expand);
break;
case PROP_CHILD_Y_EXPAND:
table_child_set_expand (self,
self->x_expand,
g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_table_child_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterTableChild *self = CLUTTER_TABLE_CHILD (gobject);
switch (prop_id)
{
case PROP_CHILD_ROW:
g_value_set_int (value, self->row);
break;
case PROP_CHILD_COLUMN:
g_value_set_int (value, self->col);
break;
case PROP_CHILD_ROW_SPAN:
g_value_set_int (value, self->row_span);
break;
case PROP_CHILD_COLUMN_SPAN:
g_value_set_int (value, self->col_span);
break;
case PROP_CHILD_X_ALIGN:
g_value_set_enum (value, self->x_align);
break;
case PROP_CHILD_Y_ALIGN:
g_value_set_enum (value, self->y_align);
break;
case PROP_CHILD_X_FILL:
g_value_set_boolean (value, self->x_fill);
break;
case PROP_CHILD_Y_FILL:
g_value_set_boolean (value, self->y_fill);
break;
case PROP_CHILD_X_EXPAND:
g_value_set_boolean (value, self->x_expand);
break;
case PROP_CHILD_Y_EXPAND:
g_value_set_boolean (value, self->y_expand);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_table_child_class_init (ClutterTableChildClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
GParamSpec *pspec;
gobject_class->set_property = clutter_table_child_set_property;
gobject_class->get_property = clutter_table_child_get_property;
pspec = g_param_spec_int ("column",
P_("Column Number"),
P_("The column the widget resides in"),
0, G_MAXINT,
0,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_COLUMN, pspec);
pspec = g_param_spec_int ("row",
P_("Row Number"),
P_("The row the widget resides in"),
0, G_MAXINT,
0,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_ROW, pspec);
pspec = g_param_spec_int ("column-span",
P_("Column Span"),
P_("The number of columns the widget should span"),
1, G_MAXINT,
1,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_COLUMN_SPAN, pspec);
pspec = g_param_spec_int ("row-span",
P_("Row Span"),
P_("The number of rows the widget should span"),
1, G_MAXINT,
1,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_ROW_SPAN, pspec);
pspec = g_param_spec_boolean ("x-expand",
P_("Horizontal Expand"),
P_("Allocate extra space for the child in horizontal axis"),
FALSE,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_X_EXPAND, pspec);
pspec = g_param_spec_boolean ("y-expand",
P_("Vertical Expand"),
P_("Allocate extra space for the child in vertical axis"),
FALSE,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_Y_EXPAND, pspec);
pspec = g_param_spec_boolean ("x-fill",
P_("Horizontal Fill"),
P_("Whether the child should receive priority when the container is allocating spare space on the horizontal axis"),
FALSE,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_X_FILL, pspec);
pspec = g_param_spec_boolean ("y-fill",
P_("Vertical Fill"),
P_("Whether the child should receive priority when the container is allocating spare space on the vertical axis"),
FALSE,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_Y_FILL, pspec);
/**
* ClutterTableLayout:x-align:
*
* The horizontal alignment of the actor within the cell
*
* Since: 1.4
*/
pspec = g_param_spec_enum ("x-align",
P_("Horizontal Alignment"),
P_("Horizontal alignment of the actor within the cell"),
CLUTTER_TYPE_TABLE_ALIGNMENT,
CLUTTER_TABLE_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_X_ALIGN, pspec);
/**
* ClutterTableLayout:y-align:
*
* The vertical alignment of the actor within the cell
*
* Since: 1.4
*/
pspec = g_param_spec_enum ("y-align",
P_("Vertical Alignment"),
P_("Vertical alignment of the actor within the cell"),
CLUTTER_TYPE_TABLE_ALIGNMENT,
CLUTTER_TABLE_ALIGNMENT_CENTER,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_CHILD_Y_ALIGN, pspec);
}
static void
clutter_table_child_init (ClutterTableChild *self)
{
self->col_span = 1;
self->row_span = 1;
self->x_align = CLUTTER_TABLE_ALIGNMENT_CENTER;
self->y_align = CLUTTER_TABLE_ALIGNMENT_CENTER;
self->x_expand = TRUE;
self->y_expand = TRUE;
self->x_fill = TRUE;
self->y_fill = TRUE;
self->has_last_allocation = FALSE;
}
static GType
clutter_table_layout_get_child_meta_type (ClutterLayoutManager *manager)
{
return CLUTTER_TYPE_TABLE_CHILD;
}
static void
clutter_table_layout_set_container (ClutterLayoutManager *layout,
ClutterContainer *container)
{
ClutterTableLayoutPrivate *priv = CLUTTER_TABLE_LAYOUT (layout)->priv;
priv->container = container;
}
static void
update_row_col (ClutterTableLayout *layout,
ClutterContainer *container)
{
ClutterTableLayoutPrivate *priv = layout->priv;
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (layout);
ClutterActor *actor, *child;
gint n_cols, n_rows;
n_cols = n_rows = 0;
if (container == NULL)
goto out;
actor = CLUTTER_ACTOR (container);
for (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
ClutterTableChild *meta;
meta =
CLUTTER_TABLE_CHILD (clutter_layout_manager_get_child_meta (manager,
container,
child));
n_cols = MAX (n_cols, meta->col + meta->col_span);
n_rows = MAX (n_rows, meta->row + meta->row_span);
}
out:
priv->n_cols = n_cols;
priv->n_rows = n_rows;
}
static void
calculate_col_widths (ClutterTableLayout *self,
ClutterContainer *container,
gint for_width)
{
ClutterTableLayoutPrivate *priv = self->priv;
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (self);
ClutterActor *actor, *child;
gint i;
DimensionData *columns;
update_row_col (self, container);
g_array_set_size (priv->columns, 0);
g_array_set_size (priv->columns, priv->n_cols);
columns = (DimensionData *) (void *) priv->columns->data;
/* reset the visibility of all columns */
priv->visible_cols = 0;
for (i = 0; i < priv->n_cols; i++)
{
columns[i].expand = FALSE;
columns[i].visible = FALSE;
}
actor = CLUTTER_ACTOR (container);
/* STAGE ONE: calculate column widths for non-spanned children */
for (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
ClutterTableChild *meta;
DimensionData *col;
gfloat c_min, c_pref;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta =
CLUTTER_TABLE_CHILD (clutter_layout_manager_get_child_meta (manager,
container,
child));
if (meta->col_span > 1)
continue;
col = &columns[meta->col];
if (!col->visible)
{
col->visible = TRUE;
priv->visible_cols += 1;
}
clutter_actor_get_preferred_width (child, -1, &c_min, &c_pref);
col->min_size = MAX (col->min_size, c_min);
col->pref_size = MAX (col->pref_size, c_pref);
if (!col->expand)
col->expand = meta->x_expand;
}
/* STAGE TWO: take spanning children into account */
for (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
ClutterTableChild *meta;
gfloat c_min, c_pref;
gfloat min_width, pref_width;
gint start_col, end_col;
gint n_expand;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta =
CLUTTER_TABLE_CHILD (clutter_layout_manager_get_child_meta (manager,
container,
child));
if (meta->col_span < 2)
continue;
start_col = meta->col;
end_col = meta->col + meta->col_span - 1;
clutter_actor_get_preferred_width (child, -1, &c_min, &c_pref);
/* check there is enough room for this actor */
min_width = 0;
pref_width = 0;
n_expand = 0;
for (i = start_col; i <= end_col; i++)
{
min_width += columns[i].min_size;
pref_width += columns[i].pref_size;
if (columns[i].expand)
n_expand++;
if (!columns[i].visible)
{
columns[i].visible = TRUE;
priv->visible_cols += 1;
}
if (!columns[i].expand)
columns[i].expand = meta->x_expand;
}
min_width += priv->col_spacing * (meta->col_span - 1);
pref_width += priv->col_spacing * (meta->col_span - 1);
/* see calculate_row_heights() for comments */
/* (1) */
if (c_min > min_width)
{
/* (2) */
/* we can start from preferred width and decrease */
if (pref_width > c_min)
{
for (i = start_col; i <= end_col; i++)
columns[i].final_size = columns[i].pref_size;
while (pref_width > c_min)
{
for (i = start_col; i <= end_col; i++)
{
if (columns[i].final_size > columns[i].min_size)
{
columns[i].final_size--;
pref_width--;
}
}
}
for (i = start_col; i <= end_col; i++)
columns[i].min_size = columns[i].final_size;
}
else
{
/* (3) */
/* we can expand from preferred size */
gfloat expand_by;
expand_by = c_pref - pref_width;
for (i = start_col; i <= end_col; i++)
{
if (n_expand)
{
if (columns[i].expand)
columns[i].min_size = columns[i].pref_size
+ expand_by / n_expand;
}
else
columns[i].min_size = columns[i].pref_size
+ expand_by / meta->col_span;
}
}
}
}
/* calculate final widths */
if (for_width >= 0)
{
gfloat min_width, pref_width;
gint n_expand;
min_width = 0;
pref_width = 0;
n_expand = 0;
for (i = 0; i < self->priv->n_cols; i++)
{
pref_width += columns[i].pref_size;
min_width += columns[i].min_size;
if (columns[i].expand)
n_expand++;
}
pref_width += priv->col_spacing * (priv->n_cols - 1);
min_width += priv->col_spacing * (priv->n_cols - 1);
if (for_width <= min_width)
{
/* erk, we can't shrink this! */
for (i = 0; i < priv->n_cols; i++)
columns[i].final_size = columns[i].min_size;
return;
}
if (for_width == pref_width)
{
/* perfect! */
for (i = 0; i < self->priv->n_cols; i++)
columns[i].final_size = columns[i].pref_size;
return;
}
/* for_width is between min_width and pref_width */
if (for_width < pref_width && for_width > min_width)
{
gfloat width;
/* shrink columns until they reach min_width */
/* start with all columns at preferred size */
for (i = 0; i < self->priv->n_cols; i++)
columns[i].final_size = columns[i].pref_size;
width = pref_width;
while (width > for_width)
{
for (i = 0; i < self->priv->n_cols; i++)
{
if (columns[i].final_size > columns[i].min_size)
{
columns[i].final_size--;
width--;
}
}
}
return;
}
/* expand columns */
if (for_width > pref_width)
{
gfloat extra_width = for_width - pref_width;
gint remaining;
if (n_expand)
remaining = (gint) extra_width % n_expand;
else
remaining = (gint) extra_width % priv->n_cols;
for (i = 0; i < self->priv->n_cols; i++)
{
if (columns[i].expand)
{
columns[i].final_size = columns[i].pref_size
+ (extra_width / n_expand);
}
else
columns[i].final_size = columns[i].pref_size;
}
/* distribute the remainder among children */
i = 0;
while (remaining)
{
columns[i].final_size++;
i++;
remaining--;
}
}
}
}
static void
calculate_row_heights (ClutterTableLayout *self,
ClutterContainer *container,
gint for_height)
{
ClutterTableLayoutPrivate *priv = self->priv;
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (self);
ClutterActor *actor, *child;
gint i;
DimensionData *rows, *columns;
update_row_col (self, container);
g_array_set_size (priv->rows, 0);
g_array_set_size (priv->rows, self->priv->n_rows);
rows = (DimensionData *) (void *) priv->rows->data;
columns = (DimensionData *) (void *) priv->columns->data;
/* reset the visibility of all rows */
priv->visible_rows = 0;
for (i = 0; i < priv->n_rows; i++)
{
rows[i].expand = FALSE;
rows[i].visible = FALSE;
}
actor = CLUTTER_ACTOR (container);
/* STAGE ONE: calculate row heights for non-spanned children */
for (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
ClutterTableChild *meta;
DimensionData *row;
gfloat c_min, c_pref;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta =
CLUTTER_TABLE_CHILD (clutter_layout_manager_get_child_meta (manager,
container,
child));
if (meta->row_span > 1)
continue;
row = &rows[meta->row];
if (!row->visible)
{
row->visible = TRUE;
priv->visible_rows += 1;
}
clutter_actor_get_preferred_height (child, columns[meta->col].final_size,
&c_min, &c_pref);
row->min_size = MAX (row->min_size, c_min);
row->pref_size = MAX (row->pref_size, c_pref);
if (!row->expand)
row->expand = meta->y_expand;
}
/* STAGE TWO: take spanning children into account */
for (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
ClutterTableChild *meta;
gfloat c_min, c_pref;
gfloat min_height, pref_height;
gint start_row, end_row;
gint n_expand;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta =
CLUTTER_TABLE_CHILD (clutter_layout_manager_get_child_meta (manager,
container,
child));
if (meta->row_span < 2)
continue;
start_row = meta->row;
end_row = meta->row + meta->row_span - 1;
clutter_actor_get_preferred_height (child, columns[meta->col].final_size,
&c_min, &c_pref);
/* check there is enough room for this actor */
min_height = 0;
pref_height = 0;
n_expand = 0;
for (i = start_row; i <= end_row; i++)
{
min_height += rows[i].min_size;
pref_height += rows[i].pref_size;
if (rows[i].expand)
n_expand++;
if (!rows[i].visible)
{
rows[i].visible = TRUE;
priv->visible_rows += 1;
}
if (!rows[i].expand)
rows[i].expand = meta->y_expand;
}
min_height += priv->row_spacing * (meta->row_span - 1);
pref_height += priv->row_spacing * (meta->row_span - 1);
/* 1) If the minimum height of the rows spanned is less than the
* minimum height of the child that is spanning them, then we
* must increase the minimum height of the rows spanned.
*
* 2) If the preferred height of the spanned rows is more than
* the minimum height of the spanning child, then we can start
* at this size and decrease each row evenly.
*
* 3) If the preferred height of the rows is more than the minimum
* height of the spanned child, then we can start at the preferred
* height and expand.
*/
/* (1) */
if (c_min > min_height)
{
/* (2) */
/* we can start from preferred height and decrease */
if (pref_height > c_min)
{
for (i = start_row; i <= end_row; i++)
rows[i].final_size = rows[i].pref_size;
while (pref_height > c_min)
{
for (i = start_row; i <= end_row; i++)
{
if (rows[i].final_size > rows[i].min_size)
{
rows[i].final_size--;
pref_height--;
}
}
}
for (i = start_row; i <= end_row; i++)
rows[i].min_size = rows[i].final_size;
}
else
{
/* (3) */
/* we can expand from preferred size */
gfloat expand_by = c_pref - pref_height;
for (i = start_row; i <= end_row; i++)
{
if (n_expand)
{
if (rows[i].expand)
rows[i].min_size = rows[i].pref_size
+ expand_by / n_expand;
}
else
rows[i].min_size = rows[i].pref_size
+ expand_by / meta->row_span;
}
}
}
}
/* calculate final heights */
if (for_height >= 0)
{
gfloat min_height, pref_height;
gint n_expand;
min_height = 0;
pref_height = 0;
n_expand = 0;
for (i = 0; i < self->priv->n_rows; i++)
{
pref_height += rows[i].pref_size;
min_height += rows[i].min_size;
if (rows[i].expand)
n_expand++;
}
pref_height += priv->row_spacing * (priv->n_rows - 1);
min_height += priv->row_spacing * (priv->n_rows - 1);
if (for_height <= min_height)
{
/* erk, we can't shrink this! */
for (i = 0; i < self->priv->n_rows; i++)
rows[i].final_size = rows[i].min_size;
return;
}
if (for_height == pref_height)
{
/* perfect! */
for (i = 0; i < self->priv->n_rows; i++)
rows[i].final_size = rows[i].pref_size;
return;
}
/* for_height is between min_height and pref_height */
if (for_height < pref_height && for_height > min_height)
{
gfloat height;
/* shrink rows until they reach min_height */
/* start with all rows at preferred size */
for (i = 0; i < self->priv->n_rows; i++)
rows[i].final_size = rows[i].pref_size;
height = pref_height;
while (height > for_height)
{
for (i = 0; i < priv->n_rows; i++)
{
if (rows[i].final_size > rows[i].min_size)
{
rows[i].final_size--;
height--;
}
}
}
return;
}
/* expand rows */
if (for_height > pref_height)
{
gfloat extra_height = for_height - pref_height;
gint remaining;
if (n_expand)
remaining = (gint) extra_height % n_expand;
else
remaining = (gint) extra_height % self->priv->n_rows;
for (i = 0; i < self->priv->n_rows; i++)
{
if (rows[i].expand)
{
rows[i].final_size = rows[i].pref_size
+ (extra_height / n_expand);
}
else
rows[i].final_size = rows[i].pref_size;
}
/* distribute the remainder among children */
i = 0;
while (remaining)
{
rows[i].final_size++;
i++;
remaining--;
}
}
}
}
static void
calculate_table_dimensions (ClutterTableLayout *self,
ClutterContainer *container,
gfloat for_width,
gfloat for_height)
{
calculate_col_widths (self, container, for_width);
calculate_row_heights (self, container, for_height);
}
static void
clutter_table_layout_get_preferred_width (ClutterLayoutManager *layout,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
ClutterTableLayout *self = CLUTTER_TABLE_LAYOUT (layout);
ClutterTableLayoutPrivate *priv = self->priv;
gfloat total_min_width, total_pref_width;
DimensionData *columns;
gint i;
update_row_col (self, container);
if (priv->n_cols < 1)
{
*min_width_p = 0;
*natural_width_p = 0;
return;
}
calculate_table_dimensions (self, container, -1, for_height);
columns = (DimensionData *) (void *) priv->columns->data;
total_min_width = (priv->visible_cols - 1) * (float) priv->col_spacing;
total_pref_width = total_min_width;
for (i = 0; i < priv->n_cols; i++)
{
total_min_width += columns[i].min_size;
total_pref_width += columns[i].pref_size;
}
if (min_width_p)
*min_width_p = total_min_width;
if (natural_width_p)
*natural_width_p = total_pref_width;
}
static void
clutter_table_layout_get_preferred_height (ClutterLayoutManager *layout,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
ClutterTableLayout *self = CLUTTER_TABLE_LAYOUT (layout);
ClutterTableLayoutPrivate *priv = self->priv;
gfloat total_min_height, total_pref_height;
DimensionData *rows;
gint i;
update_row_col (self, container);
if (priv->n_rows < 1)
{
*min_height_p = 0;
*natural_height_p = 0;
return;
}
calculate_table_dimensions (self, container, for_width, -1);
rows = (DimensionData *) (void *) priv->rows->data;
total_min_height = (priv->visible_rows - 1) * (float) priv->row_spacing;
total_pref_height = total_min_height;
for (i = 0; i < self->priv->n_rows; i++)
{
total_min_height += rows[i].min_size;
total_pref_height += rows[i].pref_size;
}
if (min_height_p)
*min_height_p = total_min_height;
if (natural_height_p)
*natural_height_p = total_pref_height;
}
static gdouble
get_table_alignment_factor (ClutterTableAlignment alignment)
{
switch (alignment)
{
case CLUTTER_TABLE_ALIGNMENT_START:
return 0.0;
case CLUTTER_TABLE_ALIGNMENT_CENTER:
return 0.5;
case CLUTTER_TABLE_ALIGNMENT_END:
return 1.0;
}
return 0.0;
}
static void
clutter_table_layout_allocate (ClutterLayoutManager *layout,
ClutterContainer *container,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterTableLayout *self = CLUTTER_TABLE_LAYOUT (layout);
ClutterTableLayoutPrivate *priv = self->priv;
ClutterActor *actor, *child;
gint row_spacing, col_spacing;
gint i;
DimensionData *rows, *columns;
update_row_col (self, container);
if (priv->n_cols < 1 || priv->n_rows < 1)
return;
actor = CLUTTER_ACTOR (container);
if (clutter_actor_get_n_children (actor) == 0)
return;
col_spacing = (priv->col_spacing);
row_spacing = (priv->row_spacing);
calculate_table_dimensions (self, container,
box->x2 - box->x1,
box->y2 - box->y1);
rows = (DimensionData *) (void *) priv->rows->data;
columns = (DimensionData *) (void *) priv->columns->data;
for (child = clutter_actor_get_first_child (actor);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, row_span, col_span;
gint col_width, row_height;
ClutterTableChild *meta;
ClutterActorBox childbox;
gint child_x, child_y;
gdouble x_align, y_align;
gboolean x_fill, y_fill;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta =
CLUTTER_TABLE_CHILD (clutter_layout_manager_get_child_meta (layout,
container,
child));
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
x_align = get_table_alignment_factor (meta->x_align);
y_align = get_table_alignment_factor (meta->y_align);
x_fill = meta->x_fill;
y_fill = meta->y_fill;
/* initialise the width and height */
col_width = columns[col].final_size;
row_height = rows[row].final_size;
/* Add the widths of the spanned columns:
*
* First check that we have a non-zero span. Then we loop over each of
* the columns that we're spanning but we stop short if we go past the
* number of columns in the table. This is necessary to avoid accessing
* uninitialised memory. We add the spacing in here too since we only
* want to add as much spacing as times we successfully span.
*/
if (col + col_span > priv->n_cols)
g_warning (G_STRLOC ": column-span exceeds number of columns");
if (row + row_span > priv->n_rows)
g_warning (G_STRLOC ": row-span exceeds number of rows");
if (col_span > 1)
{
for (i = col + 1; i < col + col_span && i < priv->n_cols; i++)
{
col_width += columns[i].final_size;
col_width += col_spacing;
}
}
/* add the height of the spanned rows */
if (row_span > 1)
{
for (i = row + 1; i < row + row_span && i < priv->n_rows; i++)
{
row_height += rows[i].final_size;
row_height += row_spacing;
}
}
/* calculate child x */
child_x = clutter_actor_box_get_x (box);
for (i = 0; i < col; i++)
{
if (columns[i].visible)
{
child_x += columns[i].final_size;
child_x += col_spacing;
}
}
/* calculate child y */
child_y = clutter_actor_box_get_y (box);
for (i = 0; i < row; i++)
{
if (rows[i].visible)
{
child_y += rows[i].final_size;
child_y += row_spacing;
}
}
/* set up childbox */
childbox.x1 = (float) child_x;
childbox.x2 = (float) MAX (0, child_x + col_width);
childbox.y1 = (float) child_y;
childbox.y2 = (float) MAX (0, child_y + row_height);
if (priv->use_animations)
{
clutter_actor_save_easing_state (child);
clutter_actor_set_easing_mode (child, priv->easing_mode);
clutter_actor_set_easing_duration (child, priv->easing_duration);
}
clutter_actor_allocate_align_fill (child, &childbox,
x_align, y_align,
x_fill, y_fill,
flags);
if (priv->use_animations)
clutter_actor_restore_easing_state (child);
}
}
static void
clutter_table_layout_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterTableLayout *self = CLUTTER_TABLE_LAYOUT (gobject);
switch (prop_id)
{
case PROP_COLUMN_SPACING:
clutter_table_layout_set_column_spacing (self, g_value_get_uint (value));
break;
case PROP_ROW_SPACING:
clutter_table_layout_set_row_spacing (self, g_value_get_uint (value));
break;
case PROP_USE_ANIMATIONS:
clutter_table_layout_set_use_animations (self, g_value_get_boolean (value));
break;
case PROP_EASING_MODE:
clutter_table_layout_set_easing_mode (self, g_value_get_ulong (value));
break;
case PROP_EASING_DURATION:
clutter_table_layout_set_easing_duration (self, g_value_get_uint (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_table_layout_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterTableLayoutPrivate *priv = CLUTTER_TABLE_LAYOUT (gobject)->priv;
switch (prop_id)
{
case PROP_ROW_SPACING:
g_value_set_uint (value, priv->row_spacing);
break;
case PROP_COLUMN_SPACING:
g_value_set_uint (value, priv->col_spacing);
break;
case PROP_USE_ANIMATIONS:
g_value_set_boolean (value, priv->use_animations);
break;
case PROP_EASING_MODE:
g_value_set_ulong (value, priv->easing_mode);
break;
case PROP_EASING_DURATION:
g_value_set_uint (value, priv->easing_duration);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
clutter_table_layout_finalize (GObject *gobject)
{
ClutterTableLayoutPrivate *priv = CLUTTER_TABLE_LAYOUT (gobject)->priv;
g_array_free (priv->columns, TRUE);
g_array_free (priv->rows, TRUE);
G_OBJECT_CLASS (clutter_table_layout_parent_class)->finalize (gobject);
}
static void
clutter_table_layout_class_init (ClutterTableLayoutClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterLayoutManagerClass *layout_class;
GParamSpec *pspec;
layout_class = CLUTTER_LAYOUT_MANAGER_CLASS (klass);
gobject_class->set_property = clutter_table_layout_set_property;
gobject_class->get_property = clutter_table_layout_get_property;
gobject_class->finalize = clutter_table_layout_finalize;
layout_class->get_preferred_width =
clutter_table_layout_get_preferred_width;
layout_class->get_preferred_height =
clutter_table_layout_get_preferred_height;
layout_class->allocate = clutter_table_layout_allocate;
layout_class->set_container = clutter_table_layout_set_container;
layout_class->get_child_meta_type =
clutter_table_layout_get_child_meta_type;
g_type_class_add_private (klass, sizeof (ClutterTableLayoutPrivate));
/**
* ClutterTableLayout:column-spacing:
*
* The spacing between columns of the #ClutterTableLayout, in pixels
*
* Since: 1.4
*/
pspec = g_param_spec_uint ("column-spacing",
P_("Column Spacing"),
P_("Spacing between columns"),
0, G_MAXUINT, 0,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_COLUMN_SPACING, pspec);
/**
* ClutterTableLayout:row-spacing:
*
* The spacing between rows of the #ClutterTableLayout, in pixels
*
* Since: 1.4
*/
pspec = g_param_spec_uint ("row-spacing",
P_("Row Spacing"),
P_("Spacing between rows"),
0, G_MAXUINT, 0,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_ROW_SPACING, pspec);
/**
* ClutterTableLayout:use-animations:
*
* Whether the #ClutterTableLayout should animate changes in the
* layout properties.
*
* By default, #ClutterTableLayout will honour the easing state of
* the children when allocating them. Setting this property to
* %TRUE will override the easing state with the layout manager's
* #ClutterTableLayout:easing-mode and #ClutterTableLayout:easing-duration
* properties.
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
pspec = g_param_spec_boolean ("use-animations",
P_("Use Animations"),
P_("Whether layout changes should be animated"),
FALSE,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_USE_ANIMATIONS, pspec);
/**
* ClutterTableLayout:easing-mode:
*
* The easing mode for the animations, in case
* #ClutterTableLayout:use-animations is set to %TRUE.
*
* The easing mode has the same semantics of #ClutterAnimation:mode: it can
* either be a value from the #ClutterAnimationMode enumeration, like
* %CLUTTER_EASE_OUT_CUBIC, or a logical id as returned by
* clutter_alpha_register_func().
*
* The default value is %CLUTTER_EASE_OUT_CUBIC.
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
pspec = g_param_spec_ulong ("easing-mode",
P_("Easing Mode"),
P_("The easing mode of the animations"),
0, G_MAXULONG,
CLUTTER_EASE_OUT_CUBIC,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_EASING_MODE, pspec);
/**
* ClutterTableLayout:easing-duration:
*
* The duration of the animations, in case #ClutterTableLayout:use-animations
* is set to %TRUE.
*
* The duration is expressed in milliseconds.
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
pspec = g_param_spec_uint ("easing-duration",
P_("Easing Duration"),
P_("The duration of the animations"),
0, G_MAXUINT,
500,
CLUTTER_PARAM_READWRITE);
g_object_class_install_property (gobject_class, PROP_EASING_DURATION, pspec);
}
static void
clutter_table_layout_init (ClutterTableLayout *layout)
{
ClutterTableLayoutPrivate *priv;
layout->priv = priv = CLUTTER_TABLE_LAYOUT_GET_PRIVATE (layout);
priv->row_spacing = 0;
priv->col_spacing = 0;
priv->use_animations = FALSE;
priv->easing_mode = CLUTTER_EASE_OUT_CUBIC;
priv->easing_duration = 500;
priv->columns = g_array_new (FALSE, TRUE, sizeof (DimensionData));
priv->rows = g_array_new (FALSE, TRUE, sizeof (DimensionData));
}
/**
* clutter_table_layout_new:
*
* Creates a new #ClutterTableLayout layout manager
*
* Return value: the newly created #ClutterTableLayout
*
* Since: 1.4
*/
ClutterLayoutManager *
clutter_table_layout_new (void)
{
return g_object_new (CLUTTER_TYPE_TABLE_LAYOUT, NULL);
}
/**
* clutter_table_layout_set_column_spacing:
* @layout: a #ClutterTableLayout
* @spacing: the spacing between columns of the layout, in pixels
*
* Sets the spacing between columns of @layout
*
* Since: 1.4
*/
void
clutter_table_layout_set_column_spacing (ClutterTableLayout *layout,
guint spacing)
{
ClutterTableLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
priv = layout->priv;
if (priv->col_spacing != spacing)
{
ClutterLayoutManager *manager;
priv->col_spacing = spacing;
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
g_object_notify (G_OBJECT (layout), "column-spacing");
}
}
/**
* clutter_table_layout_get_column_spacing:
* @layout: a #ClutterTableLayout
*
* Retrieves the spacing set using clutter_table_layout_set_column_spacing()
*
* Return value: the spacing between columns of the #ClutterTableLayout
*
* Since: 1.4
*/
guint
clutter_table_layout_get_column_spacing (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout), 0);
return layout->priv->col_spacing;
}
/**
* clutter_table_layout_set_row_spacing:
* @layout: a #ClutterTableLayout
* @spacing: the spacing between rows of the layout, in pixels
*
* Sets the spacing between rows of @layout
*
* Since: 1.4
*/
void
clutter_table_layout_set_row_spacing (ClutterTableLayout *layout,
guint spacing)
{
ClutterTableLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
priv = layout->priv;
if (priv->row_spacing != spacing)
{
ClutterLayoutManager *manager;
priv->row_spacing = spacing;
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
g_object_notify (G_OBJECT (layout), "row-spacing");
}
}
/**
* clutter_table_layout_get_row_spacing:
* @layout: a #ClutterTableLayout
*
* Retrieves the spacing set using clutter_table_layout_set_row_spacing()
*
* Return value: the spacing between rows of the #ClutterTableLayout
*
* Since: 1.4
*/
guint
clutter_table_layout_get_row_spacing (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout), 0);
return layout->priv->row_spacing;
}
/**
* clutter_table_layout_pack:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor
* @column: the column the @actor should be put, or -1 to append
* @row: the row the @actor should be put, or -1 to append
*
* Packs @actor inside the #ClutterContainer associated to @layout
* at the given row and column.
*
* Since: 1.4
*/
void
clutter_table_layout_pack (ClutterTableLayout *layout,
ClutterActor *actor,
gint column,
gint row)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before adding children",
G_OBJECT_TYPE_NAME (layout));
return;
}
update_row_col (CLUTTER_TABLE_LAYOUT (layout), priv->container);
clutter_container_add_actor (priv->container, actor);
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
if (row < 0)
row = priv->n_rows + 1;
if (column < 0)
column = priv->n_cols + 1;
table_child_set_position (CLUTTER_TABLE_CHILD (meta), column, row);
}
/**
* clutter_table_layout_set_span:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @column_span: Column span for @actor
* @row_span: Row span for @actor
*
* Sets the row and column span for @actor
* inside @layout
*
* Since: 1.4
*/
void
clutter_table_layout_set_span (ClutterTableLayout *layout,
ClutterActor *actor,
gint column_span,
gint row_span)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
table_child_set_span (CLUTTER_TABLE_CHILD (meta), column_span, row_span);
}
/**
* clutter_table_layout_get_span:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @column_span: (out): return location for the col span
* @row_span: (out): return location for the row span
*
* Retrieves the row and column span for @actor as set using
* clutter_table_layout_pack() or clutter_table_layout_set_span()
*
* Since: 1.4
*/
void
clutter_table_layout_get_span (ClutterTableLayout *layout,
ClutterActor *actor,
gint *column_span,
gint *row_span)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
if (column_span)
*column_span = CLUTTER_TABLE_CHILD (meta)->col_span;
if (row_span)
*row_span = CLUTTER_TABLE_CHILD (meta)->row_span;
}
/**
* clutter_table_layout_set_alignment:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @x_align: Horizontal alignment policy for @actor
* @y_align: Vertical alignment policy for @actor
*
* Sets the horizontal and vertical alignment policies for @actor
* inside @layout
*
* Since: 1.4
*/
void
clutter_table_layout_set_alignment (ClutterTableLayout *layout,
ClutterActor *actor,
ClutterTableAlignment x_align,
ClutterTableAlignment y_align)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
table_child_set_align (CLUTTER_TABLE_CHILD (meta), x_align, y_align);
}
/**
* clutter_table_layout_get_alignment:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @x_align: (out): return location for the horizontal alignment policy
* @y_align: (out): return location for the vertical alignment policy
*
* Retrieves the horizontal and vertical alignment policies for @actor
* as set using clutter_table_layout_pack() or
* clutter_table_layout_set_alignment().
*
* Since: 1.4
*/
void
clutter_table_layout_get_alignment (ClutterTableLayout *layout,
ClutterActor *actor,
ClutterTableAlignment *x_align,
ClutterTableAlignment *y_align)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
if (x_align)
*x_align = CLUTTER_TABLE_CHILD (meta)->x_align;
if (y_align)
*y_align = CLUTTER_TABLE_CHILD (meta)->y_align;
}
/**
* clutter_table_layout_set_fill:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @x_fill: whether @actor should fill horizontally the allocated space
* @y_fill: whether @actor should fill vertically the allocated space
*
* Sets the horizontal and vertical fill policies for @actor
* inside @layout
*
* Since: 1.4
*/
void
clutter_table_layout_set_fill (ClutterTableLayout *layout,
ClutterActor *actor,
gboolean x_fill,
gboolean y_fill)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
table_child_set_fill (CLUTTER_TABLE_CHILD (meta), x_fill, y_fill);
}
/**
* clutter_table_layout_get_fill:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @x_fill: (out): return location for the horizontal fill policy
* @y_fill: (out): return location for the vertical fill policy
*
* Retrieves the horizontal and vertical fill policies for @actor
* as set using clutter_table_layout_pack() or clutter_table_layout_set_fill()
*
* Since: 1.4
*/
void
clutter_table_layout_get_fill (ClutterTableLayout *layout,
ClutterActor *actor,
gboolean *x_fill,
gboolean *y_fill)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
if (x_fill)
*x_fill = CLUTTER_TABLE_CHILD (meta)->x_fill;
if (y_fill)
*y_fill = CLUTTER_TABLE_CHILD (meta)->y_fill;
}
/**
* clutter_table_layout_set_expand:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @x_expand: whether @actor should allocate extra space horizontally
* @y_expand: whether @actor should allocate extra space vertically
*
* Sets the horizontal and vertical expand policies for @actor
* inside @layout
*
* Since: 1.4
*/
void
clutter_table_layout_set_expand (ClutterTableLayout *layout,
ClutterActor *actor,
gboolean x_expand,
gboolean y_expand)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
table_child_set_expand (CLUTTER_TABLE_CHILD (meta), x_expand, y_expand);
}
/**
* clutter_table_layout_get_expand:
* @layout: a #ClutterTableLayout
* @actor: a #ClutterActor child of @layout
* @x_expand: (out): return location for the horizontal expand policy
* @y_expand: (out): return location for the vertical expand policy
*
* Retrieves the horizontal and vertical expand policies for @actor
* as set using clutter_table_layout_pack() or clutter_table_layout_set_expand()
*
* Since: 1.4
*/
void
clutter_table_layout_get_expand (ClutterTableLayout *layout,
ClutterActor *actor,
gboolean *x_expand,
gboolean *y_expand)
{
ClutterTableLayoutPrivate *priv;
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
priv = layout->priv;
if (priv->container == NULL)
{
g_warning ("The layout of type '%s' must be associated to "
"a ClutterContainer before querying layout "
"properties",
G_OBJECT_TYPE_NAME (layout));
return;
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
meta = clutter_layout_manager_get_child_meta (manager,
priv->container,
actor);
if (meta == NULL)
{
g_warning ("No layout meta found for the child of type '%s' "
"inside the layout manager of type '%s'",
G_OBJECT_TYPE_NAME (actor),
G_OBJECT_TYPE_NAME (manager));
return;
}
g_assert (CLUTTER_IS_TABLE_CHILD (meta));
if (x_expand)
*x_expand = CLUTTER_TABLE_CHILD (meta)->x_expand;
if (y_expand)
*y_expand = CLUTTER_TABLE_CHILD (meta)->y_expand;
}
/**
* clutter_table_layout_set_use_animations:
* @layout: a #ClutterTableLayout
* @animate: %TRUE if the @layout should use animations
*
* Sets whether @layout should animate changes in the layout properties
*
* The duration of the animations is controlled by
* clutter_table_layout_set_easing_duration(); the easing mode to be used
* by the animations is controlled by clutter_table_layout_set_easing_mode()
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
void
clutter_table_layout_set_use_animations (ClutterTableLayout *layout,
gboolean animate)
{
ClutterTableLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
priv = layout->priv;
animate = !!animate;
if (priv->use_animations != animate)
{
priv->use_animations = animate;
g_object_notify (G_OBJECT (layout), "use-animations");
}
}
/**
* clutter_table_layout_get_use_animations:
* @layout: a #ClutterTableLayout
*
* Retrieves whether @layout should animate changes in the layout properties
*
* Since clutter_table_layout_set_use_animations()
*
* Return value: %TRUE if the animations should be used, %FALSE otherwise
*
* Since: 1.4
*
* Deprecated: 1.12
*/
gboolean
clutter_table_layout_get_use_animations (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout), FALSE);
return layout->priv->use_animations;
}
/**
* clutter_table_layout_set_easing_mode:
* @layout: a #ClutterTableLayout
* @mode: an easing mode, either from #ClutterAnimationMode or a logical id
* from clutter_alpha_register_func()
*
* Sets the easing mode to be used by @layout when animating changes in layout
* properties
*
* Use clutter_table_layout_set_use_animations() to enable and disable the
* animations
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
void
clutter_table_layout_set_easing_mode (ClutterTableLayout *layout,
gulong mode)
{
ClutterTableLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
priv = layout->priv;
if (priv->easing_mode != mode)
{
priv->easing_mode = mode;
g_object_notify (G_OBJECT (layout), "easing-mode");
}
}
/**
* clutter_table_layout_get_easing_mode:
* @layout: a #ClutterTableLayout
*
* Retrieves the easing mode set using clutter_table_layout_set_easing_mode()
*
* Return value: an easing mode
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
gulong
clutter_table_layout_get_easing_mode (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout),
CLUTTER_EASE_OUT_CUBIC);
return layout->priv->easing_mode;
}
/**
* clutter_table_layout_set_easing_duration:
* @layout: a #ClutterTableLayout
* @msecs: the duration of the animations, in milliseconds
*
* Sets the duration of the animations used by @layout when animating changes
* in the layout properties
*
* Use clutter_table_layout_set_use_animations() to enable and disable the
* animations
*
* Since: 1.4
*
* Deprecated: 1.12: #ClutterTableLayout will honour the easing state
* of the children when allocating them
*/
void
clutter_table_layout_set_easing_duration (ClutterTableLayout *layout,
guint msecs)
{
ClutterTableLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout));
priv = layout->priv;
if (priv->easing_duration != msecs)
{
priv->easing_duration = msecs;
g_object_notify (G_OBJECT (layout), "easing-duration");
}
}
/**
* clutter_table_layout_get_easing_duration:
* @layout: a #ClutterTableLayout
*
* Retrieves the duration set using clutter_table_layout_set_easing_duration()
*
* Return value: the duration of the animations, in milliseconds
*
* Since: 1.4
*
* Deprecated: 1.12
*/
guint
clutter_table_layout_get_easing_duration (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout), 500);
return layout->priv->easing_duration;
}
/**
* clutter_table_layout_get_row_count:
* @layout: A #ClutterTableLayout
*
* Retrieve the current number rows in the @layout
*
* Returns: the number of rows
*
* Since: 1.4
*/
gint
clutter_table_layout_get_row_count (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout), -1);
update_row_col (layout, layout->priv->container);
return CLUTTER_TABLE_LAYOUT (layout)->priv->n_rows;
}
/**
* clutter_table_layout_get_column_count:
* @layout: A #ClutterTableLayout
*
* Retrieve the current number of columns in @layout
*
* Returns: the number of columns
*
* Since: 1.4
*/
gint
clutter_table_layout_get_column_count (ClutterTableLayout *layout)
{
g_return_val_if_fail (CLUTTER_IS_TABLE_LAYOUT (layout), -1);
update_row_col (layout, layout->priv->container);
return CLUTTER_TABLE_LAYOUT (layout)->priv->n_cols;
}
Reference in New Issue View Git Blame Copy Permalink