static void
mx_table_actor_removed (ClutterContainer *container,
ClutterActor *actor)
{
MxTablePrivate *priv = MX_TABLE (container)->priv;
gint rows, cols;
MxTableChild *meta;
ClutterActorIter iter;
ClutterActor *child;
if ((ClutterActor *)priv->last_focus == actor)
priv->last_focus = NULL;
/* update row/column count */
rows = 0;
cols = 0;
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (container));
while (clutter_actor_iter_next (&iter, &child))
{
meta = (MxTableChild *) clutter_container_get_child_meta (container,
child);
rows = MAX (rows, meta->row + meta->row_span);
cols = MAX (cols, meta->col + meta->col_span);
}
priv->n_rows = rows;
priv->n_cols = cols;
clutter_actor_queue_relayout (CLUTTER_ACTOR (container));
}
/**
* mx_table_insert_actor:
* @table: a #MxTable
* @actor: the child to insert
* @row: the row to place the child into
* @column: the column to place the child into
*
* Insert an actor at the specified row and column
*
* Note, column and rows numbers start from zero
*/
void
mx_table_insert_actor (MxTable *table,
ClutterActor *actor,
gint row,
gint column)
{
MxTableChild *meta;
g_return_if_fail (MX_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
g_return_if_fail (row >= -1);
g_return_if_fail (column >= -1);
if (row < 0)
row = table->priv->n_rows + 1;
if (column < 0)
column = table->priv->n_cols + 1;
clutter_actor_add_child (CLUTTER_ACTOR (table), actor);
meta =
(MxTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table),
actor);
meta->row = row;
meta->col = column;
_mx_table_update_row_col (table, meta);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
}
static VALUE
rbclt_container_get_child_meta (VALUE self, VALUE child)
{
ClutterContainer *container = CLUTTER_CONTAINER (RVAL2GOBJ (self));
return GOBJ2RVAL (clutter_container_get_child_meta (container,
RVAL2GOBJ (child)));
}
static StTableChild*
get_child_meta (StTable *table,
ClutterActor *child)
{
StTableChild *meta;
meta = (StTableChild*) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
return meta;
}
static inline void
container_get_child_property (ClutterContainer *container,
ClutterActor *actor,
GValue *value,
GParamSpec *pspec)
{
ClutterChildMeta *data;
data = clutter_container_get_child_meta (container, actor);
g_object_get_property (G_OBJECT (data), pspec->name, value);
}
static gint
penge_block_container_get_child_column_span (PengeBlockContainer *container,
ClutterActor *child)
{
PengeBlockContainerChild *child_meta;
child_meta = (PengeBlockContainerChild *)
clutter_container_get_child_meta ((ClutterContainer *)container,
child);
return child_meta->col_span;
}
/*
* ClutterContainer Implementation
*/
static void
mx_table_actor_added (ClutterContainer *container,
ClutterActor *actor)
{
MxTableChild *meta;
meta = (MxTableChild *) clutter_container_get_child_meta (container, actor);
/* default position of the actor is 0, 0 */
_mx_table_update_row_col (MX_TABLE (container), meta);
clutter_actor_queue_relayout (CLUTTER_ACTOR (container));
}
static inline void
container_set_child_property (ClutterContainer *container,
ClutterActor *actor,
const GValue *value,
GParamSpec *pspec)
{
ClutterChildMeta *data;
ClutterContainerIface *iface;
data = clutter_container_get_child_meta (container, actor);
g_object_set_property (G_OBJECT (data), pspec->name, value);
iface = CLUTTER_CONTAINER_GET_IFACE (container);
if (G_LIKELY (iface->child_notify))
iface->child_notify (container, actor, pspec);
}
static inline void
container_set_child_property (ClutterContainer *container,
ClutterActor *actor,
const GValue *value,
GParamSpec *pspec)
{
ClutterChildMeta *data;
data = clutter_container_get_child_meta (container, actor);
g_object_set_property (G_OBJECT (data), pspec->name, value);
g_signal_emit (container, container_signals[CHILD_NOTIFY],
(pspec->flags & G_PARAM_STATIC_NAME)
? g_quark_from_static_string (pspec->name)
: g_quark_from_string (pspec->name),
actor, pspec);
}
/*
* ClutterContainer Implementation
*/
static void
st_table_actor_removed (ClutterContainer *container,
ClutterActor *actor)
{
StTablePrivate *priv = ST_TABLE (container)->priv;
GList *list, *children;
gint n_rows = 0;
gint n_cols = 0;
/* Calculate and update the number of rows / columns */
children = st_container_get_children_list (ST_CONTAINER (container));
for (list = children; list; list = list->next)
{
ClutterActor *child = CLUTTER_ACTOR (list->data);
StTableChild *meta;
if (child == actor)
continue;
meta = (StTableChild *) clutter_container_get_child_meta (container, child);
n_rows = MAX (n_rows, meta->row + 1);
n_cols = MAX (n_cols, meta->col + 1);
}
g_object_freeze_notify (G_OBJECT (container));
if (priv->n_rows != n_rows)
{
priv->n_rows = n_rows;
g_object_notify (G_OBJECT (container), "row-count");
}
if (priv->n_cols != n_cols)
{
priv->n_cols = n_cols;
g_object_notify (G_OBJECT (container), "column-count");
}
g_object_thaw_notify (G_OBJECT (container));
}
/*
* ClutterContainer Implementation
*/
static void
st_table_actor_removed (ClutterContainer *container,
ClutterActor *actor)
{
StTablePrivate *priv = ST_TABLE (container)->priv;
gint n_rows = 0;
gint n_cols = 0;
ClutterActor *child;
/* Calculate and update the number of rows / columns */
for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (container));
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
StTableChild *meta;
if (child == actor)
continue;
meta = (StTableChild *) clutter_container_get_child_meta (container, child);
n_rows = MAX (n_rows, meta->row + 1);
n_cols = MAX (n_cols, meta->col + 1);
}
g_object_freeze_notify (G_OBJECT (container));
if (priv->n_rows != n_rows)
{
priv->n_rows = n_rows;
g_object_notify (G_OBJECT (container), "row-count");
}
if (priv->n_cols != n_cols)
{
priv->n_cols = n_cols;
g_object_notify (G_OBJECT (container), "column-count");
}
g_object_thaw_notify (G_OBJECT (container));
}
/**
* mx_table_insert_actor_with_properties
* @table: a #MxTable
* @actor: the child #ClutterActor
* @row: the row to place the child into
* @column: the column to place the child into
* @first_property_name: name of the first property to set
* @...: value for the first property, followed optionally by more name/value pairs terminated with NULL.
*
* Add an actor into at the specified row and column, with additional child
* properties to set.
*/
void
mx_table_insert_actor_with_properties (MxTable *table,
ClutterActor *actor,
gint row,
gint column,
const gchar *first_property_name,
...)
{
va_list args;
MxTableChild *meta;
g_return_if_fail (MX_IS_TABLE (table));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
g_return_if_fail (row >= -1);
g_return_if_fail (column >= -1);
g_return_if_fail (first_property_name != NULL);
if (row < 0)
row = table->priv->n_rows + 1;
if (column < 0)
column = table->priv->n_cols + 1;
clutter_actor_add_child (CLUTTER_ACTOR (table), actor);
meta =
(MxTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table),
actor);
meta->row = row;
meta->col = column;
va_start (args, first_property_name);
g_object_set_valist ((GObject*) meta, first_property_name, args);
va_end (args);
_mx_table_update_row_col (table, meta);
clutter_actor_queue_relayout (CLUTTER_ACTOR (table));
}
static ClutterActor*
mx_table_find_actor_at (MxTable *table,
int row,
int column)
{
ClutterActorIter iter;
ClutterActor *actor_child;
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (table));
while (clutter_actor_iter_next (&iter, &actor_child))
{
MxTableChild *child;
child = (MxTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table),
actor_child);
if ((row >= child->row && row <= child->row + (child->row_span - 1)) &&
(column >= child->col && column <= child->col + (child->col_span - 1)))
return actor_child;
}
return NULL;
}
static void
mx_table_calculate_row_heights (MxTable *table,
gint for_height)
{
MxTablePrivate *priv = MX_TABLE (table)->priv;
gint i;
DimensionData *rows, *columns;
MxPadding padding;
ClutterActorIter iter;
ClutterActor *child;
mx_widget_get_padding (MX_WIDGET (table), &padding);
/* take padding off available height */
for_height -= (int)(padding.top + padding.bottom);
g_array_set_size (priv->rows, 0);
g_array_set_size (priv->rows, priv->n_rows);
rows = &g_array_index (priv->rows, DimensionData, 0);
columns = &g_array_index (priv->columns, DimensionData, 0);
/* Reset the visible rows */
priv->visible_rows = 0;
for (i = 0; i < priv->n_rows; i++)
rows[i].is_visible = FALSE;
/* STAGE ONE: calculate row heights for non-spanned children */
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (table));
while (clutter_actor_iter_next (&iter, &child))
{
MxTableChild *meta;
DimensionData *row;
gfloat c_min, c_pref;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta = (MxTableChild *)
clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (meta->row_span > 1)
continue;
row = &rows[meta->row];
/* If this child is visible, then its row is visible */
if (!row->is_visible)
{
row->is_visible = TRUE;
priv->visible_rows++;
}
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->final_size = row->pref_size = MAX (row->pref_size, c_pref);
row->expand = MAX (row->expand, meta->y_expand);
}
/* STAGE TWO: take spanning children into account */
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (table));
while (clutter_actor_iter_next (&iter, &child))
{
MxTableChild *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 = (MxTableChild *)
clutter_container_get_child_meta (CLUTTER_CONTAINER (table), 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 this actor is visible, then all the rows is spans are visible */
if (!rows[i].is_visible)
{
rows[i].is_visible = TRUE;
priv->visible_rows++;
}
rows[i].expand = MAX (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 that 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;
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 < 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 < priv->n_rows; i++)
{
rows[i].final_size = rows[i].min_size;
}
return;
}
if (for_height == pref_height)
{
/* perfect! */
for (i = 0; i < 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 < 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 % priv->n_rows;
for (i = 0; i < priv->n_rows; i++)
{
if (rows[i].expand)
{
if (n_expand)
{
rows[i].final_size =
rows[i].pref_size + (extra_height / n_expand);
}
else
{
rows[i].final_size =
rows[i].pref_size + (extra_height / priv->n_rows);
}
}
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
st_table_calculate_col_widths (StTable *table,
gint for_width)
{
StTablePrivate *priv = table->priv;
GList *list, *children;
gint i;
DimensionData *columns;
g_array_set_size (priv->columns, 0);
g_array_set_size (priv->columns, priv->n_cols);
columns = &g_array_index (priv->columns, DimensionData, 0);
/* Reset all the visible attributes for the columns */
priv->visible_cols = 0;
for (i = 0; i < priv->n_cols; i++)
columns[i].is_visible = FALSE;
children = st_container_get_children_list (ST_CONTAINER (table));
/* STAGE ONE: calculate column widths for non-spanned children */
for (list = children; list; list = list->next)
{
StTableChild *meta;
ClutterActor *child;
DimensionData *col;
gfloat w_min, w_pref;
child = CLUTTER_ACTOR (list->data);
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
if (meta->col_span > 1)
continue;
col = &columns[meta->col];
/* If this child is visible, then its column is visible */
if (!col->is_visible)
{
col->is_visible = TRUE;
priv->visible_cols++;
}
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);
col->min_size = MAX (col->min_size, w_min);
col->final_size = col->pref_size = MAX (col->pref_size, w_pref);
col->expand = MAX (col->expand, meta->x_expand);
}
/* STAGE TWO: take spanning children into account */
for (list = children; list; list = list->next)
{
StTableChild *meta;
ClutterActor *child;
gfloat w_min, w_pref;
gfloat min_width, pref_width;
gint start_col, end_col;
gint n_expand;
child = CLUTTER_ACTOR (list->data);
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
if (meta->col_span < 2)
continue;
start_col = meta->col;
end_col = meta->col + meta->col_span - 1;
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_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 this child is visible, then the columns it spans
are also visible */
if (!columns[i].is_visible)
{
columns[i].is_visible = TRUE;
priv->visible_cols++;
}
columns[i].expand = MAX (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 st_table_calculate_row_heights() for comments */
/* (1) */
if (w_min > min_width)
{
/* (2) */
/* we can start from preferred width and decrease */
if (pref_width > w_min)
{
for (i = start_col; i <= end_col; i++)
{
columns[i].final_size = columns[i].pref_size;
}
while (pref_width > w_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 = w_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 < 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 < 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 < priv->n_cols; i++)
{
columns[i].final_size = columns[i].pref_size;
}
width = pref_width;
while (width > for_width)
{
for (i = 0; i < 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 < priv->n_cols; i++)
{
if (columns[i].expand)
columns[i].final_size =
columns[i].pref_size + (extra_width / n_expand);
else if (!n_expand)
columns[i].final_size =
columns[i].pref_size + (extra_width / priv->n_cols);
else
columns[i].final_size = columns[i].pref_size;
}
/* distribute the remainder among children */
i = 0;
while (remaining)
{
if (columns[i].expand || !n_expand)
{
columns[i].final_size++;
remaining--;
}
i++;
}
}
}
}
static void
st_table_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
gint *min_heights, *pref_heights;
gfloat total_min_height, total_pref_height;
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gint i;
gint *min_widths;
ClutterActor *child;
/* We only support height-for-width allocation. So if we are called
* width-for-height, calculate heights based on our natural width
*/
if (for_width < 0)
{
float natural_width;
clutter_actor_get_preferred_width (self, -1, NULL, &natural_width);
for_width = natural_width;
}
if (priv->n_rows < 1)
{
*min_height_p = 0;
*natural_height_p = 0;
return;
}
st_theme_node_adjust_for_width (theme_node, &for_width);
/* Setting size to zero and then what we want it to be causes a clear if
* clear flag is set (which it should be.)
*/
g_array_set_size (priv->min_heights, 0);
g_array_set_size (priv->pref_heights, 0);
g_array_set_size (priv->min_heights, priv->n_rows);
g_array_set_size (priv->pref_heights, priv->n_rows);
/* use min_widths to help allocation of height-for-width widgets */
min_widths = st_table_calculate_col_widths (ST_TABLE (self), for_width);
min_heights = (gint *) priv->min_heights->data;
pref_heights = (gint *) priv->pref_heights->data;
/* calculate minimum row heights */
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, col_span, cell_width, row_span;
gfloat min, pref;
StTableChild *meta;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
row = meta->row;
col = meta->col;
col_span = meta->col_span;
row_span = meta->row_span;
cell_width = 0;
for (i = 0; i < col_span && col + i < priv->n_cols; i++)
cell_width += min_widths[col + i];
_st_actor_get_preferred_height (child, (float) cell_width, meta->x_fill,
&min, &pref);
if (row_span == 1 && min > min_heights[row])
min_heights[row] = min;
if (row_span == 1 && pref > pref_heights[row])
pref_heights[row] = pref;
}
/* start off with row spacing */
total_min_height = (priv->n_rows - 1) * (float) (priv->row_spacing);
total_pref_height = total_min_height;
for (i = 0; i < priv->n_rows; i++)
{
total_min_height += min_heights[i];
total_pref_height += pref_heights[i];
}
if (min_height_p)
*min_height_p = total_min_height;
if (natural_height_p)
*natural_height_p = total_pref_height;
st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
}
static void
st_table_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
gint *min_widths, *pref_widths;
gfloat total_min_width, total_pref_width;
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gint i;
ClutterActor *child;
if (priv->n_cols < 1)
{
*min_width_p = 0;
*natural_width_p = 0;
return;
}
/* Setting size to zero and then what we want it to be causes a clear if
* clear flag is set (which it should be.)
*/
g_array_set_size (priv->min_widths, 0);
g_array_set_size (priv->pref_widths, 0);
g_array_set_size (priv->min_widths, priv->n_cols);
g_array_set_size (priv->pref_widths, priv->n_cols);
min_widths = (gint *) priv->min_widths->data;
pref_widths = (gint *) priv->pref_widths->data;
/* calculate minimum row widths */
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint col, col_span;
gfloat w_min, w_pref;
StTableChild *meta;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
col_span = meta->col_span;
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);
if (col_span == 1 && w_min > min_widths[col])
min_widths[col] = w_min;
if (col_span == 1 && w_pref > pref_widths[col])
pref_widths[col] = w_pref;
}
total_min_width = (priv->n_cols - 1) * (float) priv->col_spacing;
total_pref_width = total_min_width;
for (i = 0; i < priv->n_cols; i++)
{
total_min_width += min_widths[i];
total_pref_width += pref_widths[i];
}
/* If we were requested width-for-height, then we reported minimum/natural
* heights based on our natural width. If we were allocated less than our
* natural width, then we need more height. So in the width-for-height
* case we need to disable shrinking.
*/
if (for_height >= 0)
total_min_width = total_pref_width;
if (min_width_p)
*min_width_p = total_min_width;
if (natural_width_p)
*natural_width_p = total_pref_width;
st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
}
static void
st_table_preferred_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
gint row_spacing, col_spacing;
gint i;
gint *col_widths, *row_heights;
StTable *table;
StTablePrivate *priv;
gboolean ltr;
ClutterActor *child;
table = ST_TABLE (self);
priv = ST_TABLE (self)->priv;
col_spacing = (priv->col_spacing);
row_spacing = (priv->row_spacing);
col_widths =
st_table_calculate_col_widths (table,
(int) (content_box->x2 - content_box->x1));
row_heights =
st_table_calculate_row_heights (table,
(int) (content_box->y2 - content_box->y1),
col_widths);
ltr = (clutter_actor_get_text_direction (self) == CLUTTER_TEXT_DIRECTION_LTR);
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, row_span, col_span;
gint col_width, row_height;
StTableChild *meta;
ClutterActorBox childbox;
gint child_x, child_y;
gdouble x_align_f, y_align_f;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
_st_get_align_factors (meta->x_align, meta->y_align,
&x_align_f, &y_align_f);
/* initialise the width and height */
col_width = col_widths[col];
row_height = row_heights[row];
/* 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 ("StTable: col-span exceeds number of columns");
#if 0
if (row + row_span > priv->n_rows)
g_warning ("StTable: row-span exceeds number of rows");
#endif
if (col_span > 1)
{
for (i = col + 1; i < col + col_span && i < priv->n_cols; i++)
{
col_width += col_widths[i];
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 += row_heights[i];
row_height += row_spacing;
}
}
/* calculate child x */
if (ltr)
{
child_x = (int) content_box->x1
+ col_spacing * col;
for (i = 0; i < col; i++)
child_x += col_widths[i];
}
else
{
child_x = (int) content_box->x2
- col_spacing * col;
for (i = 0; i < col; i++)
child_x -= col_widths[i];
}
/* calculate child y */
child_y = (int) content_box->y1
+ row_spacing * row;
for (i = 0; i < row; i++)
child_y += row_heights[i];
/* set up childbox */
if (ltr)
{
childbox.x1 = (float) child_x;
childbox.x2 = (float) MAX (0, child_x + col_width);
}
else
{
childbox.x2 = (float) child_x;
childbox.x1 = (float) MAX (0, child_x - col_width);
}
childbox.y1 = (float) child_y;
childbox.y2 = (float) MAX (0, child_y + row_height);
clutter_actor_allocate_align_fill (child, &childbox,
x_align_f, y_align_f,
meta->x_fill, meta->y_fill,
flags);
}
}
static gint *
st_table_calculate_row_heights (StTable *table,
gint for_height,
gint * col_widths)
{
StTablePrivate *priv = ST_TABLE (table)->priv;
gint *is_expand_row, *min_heights, *pref_heights, *row_heights, extra_row_height;
gint i, total_min_height;
gint expanded_rows = 0;
gint n_expanded_rows = 0;
ClutterActor *child;
g_array_set_size (priv->row_heights, 0);
g_array_set_size (priv->row_heights, priv->n_rows);
row_heights = (gboolean *) priv->row_heights->data;
g_array_set_size (priv->is_expand_row, 0);
g_array_set_size (priv->is_expand_row, priv->n_rows);
is_expand_row = (gboolean *) priv->is_expand_row->data;
g_array_set_size (priv->min_heights, 0);
g_array_set_size (priv->min_heights, priv->n_rows);
min_heights = (gboolean *) priv->min_heights->data;
g_array_set_size (priv->pref_heights, 0);
g_array_set_size (priv->pref_heights, priv->n_rows);
pref_heights = (gboolean *) priv->pref_heights->data;
for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (table));
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, cell_width;
gfloat h_min, h_pref;
gboolean y_expand;
StTableChild *meta;
gint col_span, row_span;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
y_expand = meta->y_expand;
col_span = meta->col_span;
row_span = meta->row_span;
if (y_expand)
is_expand_row[row] = TRUE;
/* calculate the cell width by including any spanned columns */
cell_width = 0;
for (i = 0; i < col_span && col + i < priv->n_cols; i++)
cell_width += (float)(col_widths[col + i]);
if (!meta->x_fill)
{
gfloat width;
_st_actor_get_preferred_width (child, -1, meta->y_fill, NULL, &width);
cell_width = MIN (cell_width, width);
}
_st_actor_get_preferred_height (child, cell_width, meta->x_fill,
&h_min, &h_pref);
if (row_span == 1 && h_pref > pref_heights[row])
{
pref_heights[row] = (int)(h_pref);
}
if (row_span == 1 && h_min > min_heights[row])
{
min_heights[row] = (int)(h_min);
}
}
total_min_height = 0; // priv->row_spacing * (priv->n_rows - 1);
for (i = 0; i < priv->n_rows; i++)
total_min_height += pref_heights[i];
/* calculate the remaining space and distribute it evenly onto all rows/cols
* with the x/y expand property set. */
for (i = 0; i < priv->n_rows; i++)
if (is_expand_row[i])
{
expanded_rows += pref_heights[i];
n_expanded_rows++;
}
/* extra row height = for height - row spacings - total_min_height */
for_height -= (priv->row_spacing * (priv->n_rows - 1));
extra_row_height = for_height - total_min_height;
if (extra_row_height < 0)
{
gint *skip = g_slice_alloc0 (sizeof (gint) * priv->n_rows);
gint total_shrink_height;
/* If we need to shrink rows, we need to do multiple passes.
*
* We start by assuming all rows can shrink. All rows are sized
* proportional to their height in the total table size. If a row would be
* sized smaller than its minimum size, we mark it as non-shrinkable, and
* reduce extra_row_height by the amount it has been shrunk. The amount
* it has been shrunk by is the difference between the preferred and
* minimum height, since all rows start at their preferred height. We
* also then reduce the total table size (stored in total_shrink_height) by the height
* of the row we are going to be skipping.
*
*/
/* We start by assuming all rows can shrink */
total_shrink_height = total_min_height;
for (i = 0; i < priv->n_rows; i++)
{
if (!skip[i])
{
gint tmp;
/* Calculate the height of the row by starting with the preferred
* height and taking away the extra row height proportional to
* the preferred row height over the rows that are being shrunk
*/
tmp = pref_heights[i]
+ (extra_row_height * (pref_heights[i] / (float) total_shrink_height));
if (tmp < min_heights[i])
{
/* This was a row we *were* set to shrink, but we now find it would have
* been shrunk too much. We remove it from the list of rows to shrink and
* adjust extra_row_height and total_shrink_height appropriately */
skip[i] = TRUE;
row_heights[i] = min_heights[i];
/* Reduce extra_row_height by the amount we have reduced this
* actor by */
extra_row_height += (pref_heights[i] - min_heights[i]);
/* now take off the row from the total shrink height */
total_shrink_height -= pref_heights[i];
/* restart the loop */
i = -1;
}
else
{
skip[i] = FALSE;
row_heights[i] = tmp;
}
}
}
g_slice_free1 (sizeof (gint) * priv->n_rows, skip);
}
else
{
for (i = 0; i < priv->n_rows; i++)
{
if (is_expand_row[i])
row_heights[i] = pref_heights[i] + (extra_row_height / n_expanded_rows);
else
row_heights[i] = pref_heights[i];
}
}
return row_heights;
}
static gint *
st_table_calculate_col_widths (StTable *table,
gint for_width)
{
gint total_min_width, i;
StTablePrivate *priv = table->priv;
gboolean *is_expand_col;
gint extra_col_width, n_expanded_cols = 0, expanded_cols = 0;
gint *pref_widths, *min_widths;
ClutterActor *child;
g_array_set_size (priv->is_expand_col, 0);
g_array_set_size (priv->is_expand_col, priv->n_cols);
is_expand_col = (gboolean *) priv->is_expand_col->data;
g_array_set_size (priv->pref_widths, 0);
g_array_set_size (priv->pref_widths, priv->n_cols);
pref_widths = (gint *) priv->pref_widths->data;
g_array_set_size (priv->min_widths, 0);
g_array_set_size (priv->min_widths, priv->n_cols);
min_widths = (gint *) priv->min_widths->data;
for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (table));
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint col;
gfloat w_min, w_pref;
gboolean x_expand;
StTableChild *meta;
gint col_span;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
x_expand = meta->x_expand;
col_span = meta->col_span;
if (x_expand)
is_expand_col[col] = TRUE;
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);
if (col_span == 1 && w_pref > pref_widths[col])
{
pref_widths[col] = w_pref;
}
if (col_span == 1 && w_min > min_widths[col])
{
min_widths[col] = w_min;
}
}
total_min_width = priv->col_spacing * (priv->n_cols - 1);
for (i = 0; i < priv->n_cols; i++)
total_min_width += pref_widths[i];
/* calculate the remaining space and distribute it evenly onto all rows/cols
* with the x/y expand property set. */
for (i = 0; i < priv->n_cols; i++)
if (is_expand_col[i])
{
expanded_cols += pref_widths[i];
n_expanded_cols++;
}
/* for_width - total_min_width */
extra_col_width = for_width - total_min_width;
if (extra_col_width)
for (i = 0; i < priv->n_cols; i++)
if (is_expand_col[i])
{
if (extra_col_width < 0)
{
pref_widths[i] =
MAX (min_widths[i],
pref_widths[i]
+ (extra_col_width * (pref_widths[i] / (float) expanded_cols)));
/* if we reached the minimum width for this column, we need to
* stop counting it as expanded */
if (pref_widths[i] == min_widths[i])
{
/* restart calculations :-( */
expanded_cols -= pref_widths[i];
is_expand_col[i] = 0;
n_expanded_cols--;
i = -1;
}
}
else
pref_widths[i] += extra_col_width / n_expanded_cols;
}
return pref_widths;
}
static void
st_table_homogeneous_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
gfloat col_width, row_height;
gint row_spacing, col_spacing;
StTablePrivate *priv = ST_TABLE (self)->priv;
gboolean ltr = clutter_actor_get_text_direction (self) == CLUTTER_TEXT_DIRECTION_LTR;
ClutterActor *child;
col_spacing = priv->col_spacing;
row_spacing = priv->row_spacing;
col_width = (int) ((content_box->x2 - content_box->x1
- (col_spacing * (priv->n_cols - 1)))
/ priv->n_cols + 0.5);
row_height = (int) ((content_box->y2 - content_box->y1
- (row_spacing * (priv->n_rows - 1)))
/ priv->n_rows + 0.5);
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, row_span, col_span;
StTableChild *meta;
ClutterActorBox childbox;
gdouble x_align_f, y_align_f;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
_st_get_align_factors (meta->x_align, meta->y_align,
&x_align_f, &y_align_f);
if (ltr)
{
childbox.x1 = content_box->x1 + (col_width + col_spacing) * col;
childbox.x2 = childbox.x1 + (col_width * col_span) + (col_spacing * (col_span - 1));
}
else
{
childbox.x2 = content_box->x2 - (col_width + col_spacing) * col;
childbox.x1 = childbox.x2 - (col_width * col_span) - (col_spacing * (col_span - 1));
}
childbox.y1 = content_box->y1 + (row_height + row_spacing) * row;
childbox.y2 = childbox.y1 + (row_height * row_span) + (row_spacing * (row_span - 1));
clutter_actor_allocate_align_fill (child, &childbox,
x_align_f, y_align_f,
meta->x_fill, meta->y_fill,
flags);
}
}
static void
st_table_preferred_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
GList *list, *children;
gint row_spacing, col_spacing;
gint i;
StTable *table;
StTablePrivate *priv;
gboolean ltr;
DimensionData *rows, *columns;
table = ST_TABLE (self);
priv = ST_TABLE (self)->priv;
col_spacing = (priv->col_spacing);
row_spacing = (priv->row_spacing);
st_table_calculate_dimensions (table,
content_box->x2 - content_box->x1,
content_box->y2 - content_box->y1);
ltr = (st_widget_get_direction (ST_WIDGET (self)) == ST_TEXT_DIRECTION_LTR);
rows = &g_array_index (priv->rows, DimensionData, 0);
columns = &g_array_index (priv->columns, DimensionData, 0);
children = st_container_get_children_list (ST_CONTAINER (self));
for (list = children; list; list = list->next)
{
gint row, col, row_span, col_span;
gint col_width, row_height;
StTableChild *meta;
ClutterActor *child;
ClutterActorBox childbox;
gint child_x, child_y;
StAlign x_align, y_align;
gboolean x_fill, y_fill;
child = CLUTTER_ACTOR (list->data);
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
x_align = meta->x_align;
y_align = 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 ("StTable: the child at %d,%d's col-span, %d, exceeds number of columns, %d",
col, row, col_span, priv->n_cols);
if (row + row_span > priv->n_rows)
g_warning ("StTable: the child at %d,%d's row-span, %d, exceeds number of rows, %d",
col, row, row_span, priv->n_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 */
if (ltr)
{
child_x = (int) content_box->x1
+ col_spacing * col;
for (i = 0; i < col; i++)
child_x += columns[i].final_size;
}
else
{
child_x = (int) content_box->x2
- col_spacing * col;
for (i = 0; i < col; i++)
child_x -= columns[i].final_size;
}
/* calculate child y */
child_y = (int) content_box->y1
+ row_spacing * row;
for (i = 0; i < row; i++)
child_y += rows[i].final_size;
/* set up childbox */
if (ltr)
{
childbox.x1 = (float) child_x;
childbox.x2 = (float) MAX (0, child_x + col_width);
}
else
{
childbox.x2 = (float) child_x;
childbox.x1 = (float) MAX (0, child_x - col_width);
}
childbox.y1 = (float) child_y;
childbox.y2 = (float) MAX (0, child_y + row_height);
_st_allocate_fill (ST_WIDGET (self), child, &childbox,
x_align, y_align, x_fill, y_fill);
clutter_actor_allocate (child, &childbox, flags);
}
}
static void
mx_table_preferred_allocate (ClutterActor *self,
const ClutterActorBox *box,
gboolean flags)
{
gint row_spacing, col_spacing;
gint i;
MxTable *table;
MxTablePrivate *priv;
MxPadding padding;
DimensionData *rows, *columns;
ClutterActorIter iter;
ClutterActor *child;
table = MX_TABLE (self);
priv = MX_TABLE (self)->priv;
mx_widget_get_padding (MX_WIDGET (self), &padding);
col_spacing = (priv->col_spacing);
row_spacing = (priv->row_spacing);
mx_table_calculate_dimensions (table, box->x2 - box->x1, box->y2 - box->y1);
rows = &g_array_index (priv->rows, DimensionData, 0);
columns = &g_array_index (priv->columns, DimensionData, 0);
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
{
gint row, col, row_span, col_span;
gint col_width, row_height;
MxTableChild *meta;
ClutterActorBox childbox;
gint child_x, child_y;
gdouble x_align_d, y_align_d;
gboolean x_fill, y_fill;
MxAlign x_align, y_align;
meta = (MxTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
x_align_d = meta->x_align;
y_align_d = meta->y_align;
x_fill = meta->x_fill;
y_fill = meta->y_fill;
/* Convert to MxAlign */
if (x_align_d < 1.0 / 3.0)
x_align = MX_ALIGN_START;
else if (x_align_d > 2.0 / 3.0)
x_align = MX_ALIGN_END;
else
x_align = MX_ALIGN_MIDDLE;
if (y_align_d < 1.0 / 3.0)
y_align = MX_ALIGN_START;
else if (y_align_d > 2.0 / 3.0)
y_align = MX_ALIGN_END;
else
y_align = MX_ALIGN_MIDDLE;
/* 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 ("MxTable: col-span exceeds number of columns");
if (row + row_span > priv->n_rows)
g_warning ("MxTable: 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 = (int) padding.left;
for (i = 0; i < col; i++)
{
if (columns[i].is_visible)
{
child_x += columns[i].final_size;
child_x += col_spacing;
}
}
/* calculate child y */
child_y = (int) padding.top;
for (i = 0; i < row; i++)
{
if (rows[i].is_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);
mx_allocate_align_fill (child, &childbox, x_align, y_align, x_fill, y_fill);
clutter_actor_allocate (child, &childbox, flags);
}
}
static void
st_table_homogeneous_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
GList *list, *children;
gfloat col_width, row_height;
gint row_spacing, col_spacing;
StTablePrivate *priv = ST_TABLE (self)->priv;
gboolean ltr = st_widget_get_direction (ST_WIDGET (self)) == ST_TEXT_DIRECTION_LTR;
col_spacing = priv->col_spacing;
row_spacing = priv->row_spacing;
col_width = (int) ((content_box->x2 - content_box->x1
- (col_spacing * (priv->n_cols - 1)))
/ priv->n_cols + 0.5);
row_height = (int) ((content_box->y2 - content_box->y1
- (row_spacing * (priv->n_rows - 1)))
/ priv->n_rows + 0.5);
children = st_container_get_children_list (ST_CONTAINER (self));
for (list = children; list; list = list->next)
{
gint row, col, row_span, col_span;
StTableChild *meta;
ClutterActor *child;
ClutterActorBox childbox;
StAlign x_align, y_align;
gboolean x_fill, y_fill;
child = CLUTTER_ACTOR (list->data);
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
x_align = meta->x_align;
y_align = meta->y_align;
x_fill = meta->x_fill;
y_fill = meta->y_fill;
if (ltr)
{
childbox.x1 = content_box->x1 + (col_width + col_spacing) * col;
childbox.x2 = childbox.x1 + (col_width * col_span) + (col_spacing * (col_span - 1));
}
else
{
childbox.x2 = content_box->x2 - (col_width + col_spacing) * col;
childbox.x1 = childbox.x2 - (col_width * col_span) - (col_spacing * (col_span - 1));
}
childbox.y1 = content_box->y1 + (row_height + row_spacing) * row;
childbox.y2 = childbox.y1 + (row_height * row_span) + (row_spacing * (row_span - 1));
_st_allocate_fill (ST_WIDGET (self), child, &childbox,
x_align, y_align, x_fill, y_fill);
clutter_actor_allocate (child, &childbox, flags);
}
}
static void
mx_table_calculate_col_widths (MxTable *table,
gint for_width)
{
gint i;
MxTablePrivate *priv = table->priv;
DimensionData *columns;
MxPadding padding;
ClutterActorIter iter;
ClutterActor *child;
g_array_set_size (priv->columns, 0);
g_array_set_size (priv->columns, priv->n_cols);
columns = &g_array_index (priv->columns, DimensionData, 0);
/* take off the padding values to calculate the allocatable width */
mx_widget_get_padding (MX_WIDGET (table), &padding);
for_width -= (int)(padding.left + padding.right);
/* Reset all the visible attributes for the columns */
priv->visible_cols = 0;
for (i = 0; i < priv->n_cols; i++)
columns[i].is_visible = FALSE;
/* STAGE ONE: calculate column widths for non-spanned children */
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (table));
while (clutter_actor_iter_next (&iter, &child))
{
MxTableChild *meta;
DimensionData *col;
gfloat c_min, c_pref;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
meta = (MxTableChild *)
clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (meta->col_span > 1)
continue;
col = &columns[meta->col];
/* If this child is visible, then its column is visible */
if (!col->is_visible)
{
col->is_visible = TRUE;
priv->visible_cols++;
}
clutter_actor_get_preferred_width (child, -1, &c_min, &c_pref);
col->min_size = MAX (col->min_size, c_min);
col->final_size = col->pref_size = MAX (col->pref_size, c_pref);
col->expand = MAX (col->expand, meta->x_expand);
}
/* STAGE TWO: take spanning children into account */
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (table));
while (clutter_actor_iter_next (&iter, &child))
{
MxTableChild *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 = (MxTableChild *)
clutter_container_get_child_meta (CLUTTER_CONTAINER (table), 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 this child is visible, then the columns it spans
are also visible */
if (!columns[i].is_visible)
{
columns[i].is_visible = TRUE;
priv->visible_cols++;
}
columns[i].expand = MAX (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 mx_table_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 < 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 < 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 < priv->n_cols; i++)
{
columns[i].final_size = columns[i].pref_size;
}
width = pref_width;
while (width > for_width)
{
for (i = 0; i < 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 < priv->n_cols; i++)
{
if (columns[i].expand)
{
if (n_expand)
{
columns[i].final_size =
columns[i].pref_size + (extra_width / n_expand);
}
else
{
columns[i].final_size =
columns[i].pref_size + (extra_width / priv->n_cols);
}
}
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 MxFocusable*
mx_table_move_focus (MxFocusable *focusable,
MxFocusDirection direction,
MxFocusable *from)
{
MxTablePrivate *priv = MX_TABLE (focusable)->priv;
MxTable *table = MX_TABLE (focusable);
GList *l, *childlink, *children;
MxTableChild *child_meta;
ClutterActor *child_actor;
MxFocusable *focused;
gint row, column;
ClutterActor *found;
/* find the current focus */
child_actor = CLUTTER_ACTOR (from);
child_meta = (MxTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (focusable),
child_actor);
if (!child_meta)
return NULL;
priv->last_focus = from;
/* find the next widget to focus */
switch (direction)
{
case MX_FOCUS_DIRECTION_NEXT:
children = clutter_actor_get_children (CLUTTER_ACTOR (focusable));
childlink = g_list_find (children, from);
for (l = childlink->next; l; l = g_list_next (l))
{
if (MX_IS_FOCUSABLE (l->data))
{
focused = mx_focusable_accept_focus (MX_FOCUSABLE (l->data),
MX_FOCUS_HINT_FIRST);
if (focused)
{
g_list_free (children);
return focused;
}
}
}
/* no next widgets to focus */
g_list_free (children);
return NULL;
case MX_FOCUS_DIRECTION_PREVIOUS:
children = clutter_actor_get_children (CLUTTER_ACTOR (focusable));
childlink = g_list_find (children, from);
for (l = g_list_previous (childlink); l; l = g_list_previous (l))
{
if (MX_IS_FOCUSABLE (l->data))
{
focused = mx_focusable_accept_focus (MX_FOCUSABLE (l->data),
MX_FOCUS_HINT_LAST);
if (focused)
{
g_list_free (children);
return focused;
}
}
}
/* no widget found in the previous position */
g_list_free (children);
return NULL;
case MX_FOCUS_DIRECTION_UP:
/* move focus up */
row = child_meta->row - 1;
column = child_meta->col;
focused = NULL;
while (!focused && row >= 0)
{
found = mx_table_find_actor_at (table, row, column);
if (found)
{
if (MX_IS_FOCUSABLE (found))
{
focused = mx_focusable_accept_focus (MX_FOCUSABLE (found),
MX_FOCUS_HINT_FIRST);
if (focused)
break;
}
child_meta = (MxTableChild *) clutter_container_get_child_meta
(CLUTTER_CONTAINER (focusable), found);
/* row might not be the top row if @found is a spanned actor */
row = child_meta->row - 1;
}
else
row --;
}
return focused;
case MX_FOCUS_DIRECTION_DOWN:
/* move focus down */
row = child_meta->row + child_meta->row_span;
column = child_meta->col;
focused = NULL;
while (!focused && row < priv->n_rows)
{
found = mx_table_find_actor_at (table, row, column);
if (found)
{
if (MX_IS_FOCUSABLE (found))
{
focused = mx_focusable_accept_focus (MX_FOCUSABLE (found),
MX_FOCUS_HINT_FIRST);
if (focused)
break;
}
child_meta = (MxTableChild *) clutter_container_get_child_meta
(CLUTTER_CONTAINER (focusable), found);
row = child_meta->row + child_meta->row_span;
}
else
row ++;
}
return focused;
case MX_FOCUS_DIRECTION_LEFT:
/* move focus left */
row = child_meta->row;
column = child_meta->col - 1;
focused = NULL;
while (!focused && column >= 0)
{
found = mx_table_find_actor_at (table, row, column);
if (found)
{
if (MX_IS_FOCUSABLE (found))
{
focused = mx_focusable_accept_focus (MX_FOCUSABLE (found),
MX_FOCUS_HINT_FIRST);
if (focused)
break;
}
child_meta = (MxTableChild *) clutter_container_get_child_meta
(CLUTTER_CONTAINER (focusable), found);
/* col might not be the first column if @found is a spanned actor */
column = child_meta->col - 1;
}
else
column --;
}
return focused;
case MX_FOCUS_DIRECTION_RIGHT:
/* move focus right */
row = child_meta->row;
column = child_meta->col + child_meta->col_span;
focused = NULL;
while (!focused && column < priv->n_cols)
{
found = mx_table_find_actor_at (table, row, column);
if (found)
{
if (MX_IS_FOCUSABLE (found))
{
focused = mx_focusable_accept_focus (MX_FOCUSABLE (found),
MX_FOCUS_HINT_FIRST);
if (focused)
break;
}
child_meta = (MxTableChild *) clutter_container_get_child_meta
(CLUTTER_CONTAINER (focusable), found);
column = child_meta->col + child_meta->col_span;
}
else
column ++;
}
return focused;
default:
break;
}
return NULL;
}