static void
layout_manager_real_end_animation (ClutterLayoutManager *manager)
{
ClutterTimeline *timeline;
ClutterAlpha *alpha;
alpha = g_object_get_qdata (G_OBJECT (manager), quark_layout_alpha);
if (alpha == NULL)
return;
timeline = clutter_alpha_get_timeline (alpha);
g_assert (timeline != NULL);
if (clutter_timeline_is_playing (timeline))
clutter_timeline_stop (timeline);
g_signal_handlers_disconnect_by_func (timeline,
G_CALLBACK (clutter_layout_manager_end_animation),
manager);
g_signal_handlers_disconnect_by_func (timeline,
G_CALLBACK (clutter_layout_manager_layout_changed),
manager);
g_object_set_qdata (G_OBJECT (manager), quark_layout_alpha, NULL);
clutter_layout_manager_layout_changed (manager);
}
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 VALUE
rbclt_layout_manager_layout_changed (VALUE self)
{
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (RVAL2GOBJ (self));
clutter_layout_manager_layout_changed (manager);
return Qnil;
}
/**
* clutter_flow_layout_set_column_width:
* @layout: a #ClutterFlowLayout
* @min_width: minimum width of a column
* @max_width: maximum width of a column
*
* Sets the minimum and maximum widths that a column can have
*
* Since: 1.2
*/
void
clutter_flow_layout_set_column_width (ClutterFlowLayout *layout,
gfloat min_width,
gfloat max_width)
{
ClutterFlowLayoutPrivate *priv;
gboolean notify_min = FALSE, notify_max = FALSE;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->min_col_width != min_width)
{
priv->min_col_width = min_width;
notify_min = TRUE;
}
if (priv->max_col_width != max_width)
{
priv->max_col_width = max_width;
notify_max = TRUE;
}
g_object_freeze_notify (G_OBJECT (layout));
if (notify_min || notify_max)
{
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
}
if (notify_min)
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_MIN_COLUMN_WIDTH]);
if (notify_max)
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_MAX_COLUMN_WIDTH]);
g_object_thaw_notify (G_OBJECT (layout));
}
/**
* clutter_flow_layout_set_row_height:
* @layout: a #ClutterFlowLayout
* @min_height: the minimum height of a row
* @max_height: the maximum height of a row
*
* Sets the minimum and maximum heights that a row can have
*
* Since: 1.2
*/
void
clutter_flow_layout_set_row_height (ClutterFlowLayout *layout,
gfloat min_height,
gfloat max_height)
{
ClutterFlowLayoutPrivate *priv;
gboolean notify_min = FALSE, notify_max = FALSE;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->min_row_height != min_height)
{
priv->min_row_height = min_height;
notify_min = TRUE;
}
if (priv->max_row_height != max_height)
{
priv->max_row_height = max_height;
notify_max = TRUE;
}
g_object_freeze_notify (G_OBJECT (layout));
if (notify_min || notify_max)
{
ClutterLayoutManager *manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
}
if (notify_min)
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_MIN_ROW_HEGHT]);
if (notify_max)
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_MAX_ROW_HEIGHT]);
g_object_thaw_notify (G_OBJECT (layout));
}
static void
set_y_align (ClutterBinLayout *self,
ClutterBinAlignment alignment)
{
ClutterBinLayoutPrivate *priv = self->priv;
if (priv->y_align != alignment)
{
ClutterLayoutManager *manager;
priv->y_align = alignment;
manager = CLUTTER_LAYOUT_MANAGER (self);
clutter_layout_manager_layout_changed (manager);
_clutter_notify_by_pspec (G_OBJECT (self), bin_props[PROP_Y_ALIGN]);
}
}
static void
set_layer_y_align (ClutterBinLayer *self,
ClutterBinAlignment alignment)
{
ClutterLayoutManager *manager;
ClutterLayoutMeta *meta;
if (self->y_align == alignment)
return;
self->y_align = alignment;
meta = CLUTTER_LAYOUT_META (self);
manager = clutter_layout_meta_get_manager (meta);
clutter_layout_manager_layout_changed (manager);
_clutter_notify_by_pspec (G_OBJECT (self), layer_props[PROP_LAYER_Y_ALIGN]);
}
void xfdashboard_fill_box_layout_set_keep_aspect(XfdashboardFillBoxLayout *self, gboolean inKeepAspect)
{
XfdashboardFillBoxLayoutPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_FILL_BOX_LAYOUT(self));
priv=self->priv;
/* Set new values if changed */
if(priv->keepAspect!=inKeepAspect)
{
/* Set new values and notify about properties changes */
priv->keepAspect=inKeepAspect;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardFillBoxLayoutProperties[PROP_KEEP_ASPECT]);
/* Notify for upcoming layout changes */
clutter_layout_manager_layout_changed(CLUTTER_LAYOUT_MANAGER(self));
}
}
void xfdashboard_scaled_table_layout_set_prevent_upscaling(XfdashboardScaledTableLayout *self, gboolean inPreventUpscaling)
{
XfdashboardScaledTableLayoutPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_SCALED_TABLE_LAYOUT(self));
priv=self->priv;
/* Set new value if changed */
if(priv->preventUpscaling!=inPreventUpscaling)
{
/* Set new value and notify about property change */
priv->preventUpscaling=inPreventUpscaling;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardScaledTableLayoutProperties[PROP_PREVENT_UPSCALING]);
/* Notify for upcoming layout changes */
clutter_layout_manager_layout_changed(CLUTTER_LAYOUT_MANAGER(self));
}
}
void xfdashboard_fill_box_layout_set_homogeneous(XfdashboardFillBoxLayout *self, gboolean inIsHomogeneous)
{
XfdashboardFillBoxLayoutPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_FILL_BOX_LAYOUT(self));
priv=self->priv;
/* Set new values if changed */
if(priv->isHomogeneous!=inIsHomogeneous)
{
/* Set new values and notify about properties changes */
priv->isHomogeneous=inIsHomogeneous;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardFillBoxLayoutProperties[PROP_HOMOGENEOUS]);
/* Notify for upcoming layout changes */
clutter_layout_manager_layout_changed(CLUTTER_LAYOUT_MANAGER(self));
}
}
void xfdashboard_fill_box_layout_set_spacing(XfdashboardFillBoxLayout *self, gfloat inSpacing)
{
XfdashboardFillBoxLayoutPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_FILL_BOX_LAYOUT(self));
g_return_if_fail(inSpacing>=0.0f);
priv=self->priv;
/* Set new values if changed */
if(priv->spacing!=inSpacing)
{
/* Set new values and notify about properties changes */
priv->spacing=inSpacing;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardFillBoxLayoutProperties[PROP_SPACING]);
/* Notify for upcoming layout changes */
clutter_layout_manager_layout_changed(CLUTTER_LAYOUT_MANAGER(self));
}
}
/**
* clutter_flow_layout_set_snap_to_grid:
* @layout: a #ClutterFlowLayout
* @snap_to_grid: %TRUE if @layout should place its children on a grid
*
* Whether the @layout should place its children on a grid.
*
* Since: 1.16
*/
void
clutter_flow_layout_set_snap_to_grid (ClutterFlowLayout *layout,
gboolean snap_to_grid)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->snap_to_grid != snap_to_grid)
{
priv->snap_to_grid = snap_to_grid;
clutter_layout_manager_layout_changed (CLUTTER_LAYOUT_MANAGER (layout));
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_SNAP_TO_GRID]);
}
}
void xfdashboard_scaled_table_layout_set_column_spacing(XfdashboardScaledTableLayout *self, gfloat inSpacing)
{
XfdashboardScaledTableLayoutPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_SCALED_TABLE_LAYOUT(self));
g_return_if_fail(inSpacing>=0.0f);
priv=self->priv;
/* Set new value if changed */
if(priv->columnSpacing!=inSpacing)
{
/* Set new value and notify about property change */
priv->columnSpacing=inSpacing;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardScaledTableLayoutProperties[PROP_COLUMN_SPACING]);
/* Notify for upcoming layout changes */
clutter_layout_manager_layout_changed(CLUTTER_LAYOUT_MANAGER(self));
}
}
void xfdashboard_fill_box_layout_set_orientation(XfdashboardFillBoxLayout *self, ClutterOrientation inOrientation)
{
XfdashboardFillBoxLayoutPrivate *priv;
g_return_if_fail(XFDASHBOARD_IS_FILL_BOX_LAYOUT(self));
g_return_if_fail(inOrientation==CLUTTER_ORIENTATION_HORIZONTAL ||
inOrientation==CLUTTER_ORIENTATION_VERTICAL);
priv=self->priv;
/* Set new values if changed */
if(priv->orientation!=inOrientation)
{
/* Set new values and notify about properties changes */
priv->orientation=inOrientation;
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardFillBoxLayoutProperties[PROP_ORIENTATION]);
/* Notify for upcoming layout changes */
clutter_layout_manager_layout_changed(CLUTTER_LAYOUT_MANAGER(self));
}
}
/**
* 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
*
*
*/
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_flow_layout_set_homogeneous:
* @layout: a #ClutterFlowLayout
* @homogeneous: whether the layout should be homogeneous or not
*
* Sets whether the @layout should allocate the same space for
* each child
*
* Since: 1.2
*/
void
clutter_flow_layout_set_homogeneous (ClutterFlowLayout *layout,
gboolean homogeneous)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->is_homogeneous != homogeneous)
{
ClutterLayoutManager *manager;
priv->is_homogeneous = homogeneous;
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
g_object_notify (G_OBJECT (layout), "homogeneous");
}
}
/**
* clutter_flow_layout_set_row_spacing:
* @layout: a #ClutterFlowLayout
* @spacing: the space between rows
*
* Sets the spacing between rows, in pixels
*
* Since: 1.2
*/
void
clutter_flow_layout_set_row_spacing (ClutterFlowLayout *layout,
gfloat spacing)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_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");
}
}
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));
}
}
/**
* clutter_flow_layout_set_column_spacing:
* @layout: a #ClutterFlowLayout
* @spacing: the space between columns
*
* Sets the space between columns, in pixels
*
* Since: 1.2
*/
void
clutter_flow_layout_set_column_spacing (ClutterFlowLayout *layout,
gfloat spacing)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_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_by_pspec (G_OBJECT (layout),
flow_properties[PROP_COLUMN_SPACING]);
}
}
/**
* clutter_flow_layout_set_orientation:
* @layout: a #ClutterFlowLayout
* @orientation: the orientation of the layout
*
* Sets the orientation of the flow layout
*
* The orientation controls the direction used to allocate
* the children: either horizontally or vertically. The
* orientation also controls the direction of the overflowing
*
* Since: 1.2
*/
void
clutter_flow_layout_set_orientation (ClutterFlowLayout *layout,
ClutterFlowOrientation orientation)
{
ClutterFlowLayoutPrivate *priv;
g_return_if_fail (CLUTTER_IS_FLOW_LAYOUT (layout));
priv = layout->priv;
if (priv->orientation != orientation)
{
ClutterLayoutManager *manager;
priv->orientation = orientation;
if (priv->container != NULL)
{
ClutterRequestMode request_mode;
/* we need to change the :request-mode of the container
* to match the orientation
*/
request_mode = (priv->orientation == CLUTTER_FLOW_HORIZONTAL)
? CLUTTER_REQUEST_HEIGHT_FOR_WIDTH
: CLUTTER_REQUEST_WIDTH_FOR_HEIGHT;
clutter_actor_set_request_mode (CLUTTER_ACTOR (priv->container),
request_mode);
}
manager = CLUTTER_LAYOUT_MANAGER (layout);
clutter_layout_manager_layout_changed (manager);
g_object_notify_by_pspec (G_OBJECT (layout),
flow_properties[PROP_ORIENTATION]);
}
}