void
penge_block_container_set_spacing (PengeBlockContainer *pbc,
                                   gfloat               spacing)
{
  PengeBlockContainerPrivate *priv = GET_PRIVATE (pbc);

  priv->spacing = spacing;

  g_object_notify (G_OBJECT (pbc), "spacing");

  clutter_actor_queue_relayout (CLUTTER_ACTOR (pbc));
}

/**
 * clutter_align_constraint_set_factor:
 * @align: a #ClutterAlignConstraint
 * @factor: the alignment factor, between 0.0 and 1.0
 *
 * Sets the alignment factor of the constraint
 *
 * The factor depends on the #ClutterAlignConstraint:align-axis property
 * and it is a value between 0.0 (meaning left, when
 * #ClutterAlignConstraint:align-axis is set to %CLUTTER_ALIGN_X_AXIS; or
 * meaning top, when #ClutterAlignConstraint:align-axis is set to
 * %CLUTTER_ALIGN_Y_AXIS) and 1.0 (meaning right, when
 * #ClutterAlignConstraint:align-axis is set to %CLUTTER_ALIGN_X_AXIS; or
 * meaning bottom, when #ClutterAlignConstraint:align-axis is set to
 * %CLUTTER_ALIGN_Y_AXIS). A value of 0.5 aligns in the middle in either
 * cases
 *
 * Since: 1.4
 */
void
clutter_align_constraint_set_factor (ClutterAlignConstraint *align,
                                     gfloat                  factor)
{
  g_return_if_fail (CLUTTER_IS_ALIGN_CONSTRAINT (align));

  align->factor = CLAMP (factor, 0.0, 1.0);

  if (align->actor != NULL)
    clutter_actor_queue_relayout (align->actor);

  _clutter_notify_by_pspec (G_OBJECT (align), obj_props[PROP_FACTOR]);
}

/*
 * Track size of stage
 */
static void
mpl_panel_background_stage_allocation_cb (ClutterActor *stage,
                                          GParamSpec   *spec,
                                          ClutterActor *background)
{
  gfloat width, height, swidth, sheight;

  clutter_actor_get_size (stage, &swidth, &sheight);
  clutter_actor_get_size (background, &width, &height);

  if (width != swidth || height != sheight)
    clutter_actor_queue_relayout (background);
}

/*
 * 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 void
st_widget_recompute_style (StWidget    *widget,
                           StThemeNode *old_theme_node)
{
  StThemeNode *new_theme_node = st_widget_get_theme_node (widget);

  if (!old_theme_node ||
      !st_theme_node_geometry_equal (old_theme_node, new_theme_node))
    clutter_actor_queue_relayout ((ClutterActor *) widget);

  g_signal_emit (widget, signals[STYLE_CHANGED], 0);
  widget->priv->is_style_dirty = FALSE;
}

/**
 * st_box_layout_set_align_end:
 * @box: A #StBoxLayout
 * @align_end: %TRUE if the layout should use align-end
 *
 * Set the value of the #StBoxLayout::align-end property.
 *
 */
void
st_box_layout_set_align_end (StBoxLayout *box,
                             gboolean     align_end)
{
    g_return_if_fail (ST_IS_BOX_LAYOUT (box));

    if (box->priv->is_align_end != align_end)
    {
        box->priv->is_align_end = align_end;
        clutter_actor_queue_relayout ((ClutterActor*) box);

        g_object_notify (G_OBJECT (box), "align-end");
    }
}

/**
 * st_box_layout_set_vertical:
 * @box: A #StBoxLayout
 * @vertical: %TRUE if the layout should be vertical
 *
 * Set the value of the #StBoxLayout::vertical property
 *
 */
void
st_box_layout_set_vertical (StBoxLayout *box,
                            gboolean     vertical)
{
  g_return_if_fail (ST_IS_BOX_LAYOUT (box));

  if (box->priv->is_vertical != vertical)
    {
      box->priv->is_vertical = vertical;
      clutter_actor_queue_relayout ((ClutterActor*) box);

      g_object_notify (G_OBJECT (box), "vertical");
    }
}

/**
 * st_box_layout_set_pack_start:
 * @box: A #StBoxLayout
 * @pack_start: %TRUE if the layout should use pack-start
 *
 * Set the value of the #StBoxLayout::pack-start property.
 *
 */
void
st_box_layout_set_pack_start (StBoxLayout *box,
                              gboolean     pack_start)
{
  g_return_if_fail (ST_IS_BOX_LAYOUT (box));

  if (box->priv->is_pack_start != pack_start)
    {
      box->priv->is_pack_start = pack_start;
      clutter_actor_queue_relayout ((ClutterActor*) box);

      g_object_notify (G_OBJECT (box), "pack-start");
    }
}

static void
shell_embedded_window_check_resize (GtkContainer *container)
{
  ShellEmbeddedWindow *window = SHELL_EMBEDDED_WINDOW (container);

  /* Check resize is called when a resize is queued on something
   * inside the GtkWindow; we need to make sure that in response
   * to this gtk_widget_size_request() and then
   * gtk_widget_size_allocate() are called; we defer to the Clutter
   * logic and assume it will do the right thing.
   */
  if (window->priv->actor)
    clutter_actor_queue_relayout (CLUTTER_ACTOR (window->priv->actor));
}

/**
 * clutter_gdk_set_stage_foreign:
 * @stage: a #ClutterStage
 * @window: an existing #GdkWindow
 *
 * Target the #ClutterStage to use an existing external #GdkWindow
 *
 * Return value: %TRUE if foreign window is valid
 *
 * Since: 1.10
 */
gboolean
clutter_gdk_set_stage_foreign (ClutterStage *stage,
                               GdkWindow    *window)
{
  ForeignWindowClosure closure;
  ClutterStageGdk *stage_gdk;
  ClutterStageWindow *impl;
  ClutterActor *actor;

  g_return_val_if_fail (CLUTTER_IS_STAGE (stage), FALSE);
  g_return_val_if_fail (!CLUTTER_ACTOR_IN_DESTRUCTION (stage), FALSE);
  g_return_val_if_fail (GDK_IS_WINDOW (window), FALSE);

  impl = _clutter_stage_get_window (stage);
  if (!CLUTTER_IS_STAGE_GDK (impl))
    {
      g_critical ("The Clutter backend is not a GDK backend");
      return FALSE;
    }

  stage_gdk = CLUTTER_STAGE_GDK (impl);

  if (g_object_get_data (G_OBJECT (window), "clutter-stage-window") != NULL)
    {
      g_critical ("The provided GdkWindow is already in use by another ClutterStage");
      return FALSE;
    }

  closure.stage_gdk = stage_gdk;
  closure.window = g_object_ref (window);

  actor = CLUTTER_ACTOR (stage);

  _clutter_actor_rerealize (actor,
                            set_foreign_window_callback,
                            &closure);

  /* Queue a relayout - so the stage will be allocated the new
   * window size.
   *
   * Note also that when the stage gets allocated the new
   * window size that will result in the stage's
   * priv->viewport being changed, which will in turn result
   * in the Cogl viewport changing when _clutter_do_redraw
   * calls _clutter_stage_maybe_setup_viewport().
   */
  clutter_actor_queue_relayout (actor);

  return TRUE;
}

static gboolean
_down_callback (MxMenu *self)
{
    MxMenuPrivate *priv = self->priv;
    gint last_id_offset = (priv->children->len - 1) -
                          (priv->last_shown_id - priv->id_offset);

    if(last_id_offset > priv->id_offset)
    {
        priv->id_offset++;
        clutter_actor_queue_relayout (CLUTTER_ACTOR(self));
    }
    return TRUE;
}

/**
 * st_table_child_set_y_align:
 * @table: A #StTable
 * @child: A #ClutterActor
 * @align: A #StAlign value
 *
 * Set the value of the y-align property. This will only have an effect if
 * y-fill value is set to FALSE.
 *
 */
void
st_table_child_set_y_align (StTable      *table,
                            ClutterActor *child,
                            StAlign       align)
{
  StTableChild *meta;

  g_return_if_fail (ST_IS_TABLE (table));
  g_return_if_fail (CLUTTER_IS_ACTOR (child));

  meta = get_child_meta (table, child);

  meta->y_align = align;
  clutter_actor_queue_relayout (child);
}

void
penge_block_container_set_min_tile_size (PengeBlockContainer *pbc,
                                         gfloat               width,
                                         gfloat               height)
{
  PengeBlockContainerPrivate *priv = GET_PRIVATE (pbc);

  priv->min_tile_width = width;
  priv->min_tile_height = height;

  g_object_notify (G_OBJECT (pbc), "min-tile-width");
  g_object_notify (G_OBJECT (pbc), "min-tile-height");

  clutter_actor_queue_relayout (CLUTTER_ACTOR (pbc));
}

static void
st_box_layout_style_changed (StWidget *self)
{
  StBoxLayoutPrivate *priv = ST_BOX_LAYOUT (self)->priv;
  StThemeNode *theme_node = st_widget_get_theme_node (self);
  int old_spacing = priv->spacing;
  double spacing;

  spacing = st_theme_node_get_length (theme_node, "spacing");
  priv->spacing = (int)(spacing + 0.5);
  if (priv->spacing != old_spacing)
    clutter_actor_queue_relayout (CLUTTER_ACTOR (self));

  ST_WIDGET_CLASS (st_box_layout_parent_class)->style_changed (self);
}

void
mnb_zones_preview_clear (MnbZonesPreview *preview)
{

  MnbZonesPreviewPrivate *priv = preview->priv;

  while (priv->workspace_bins)
    {
      clutter_actor_destroy (CLUTTER_ACTOR (priv->workspace_bins->data));
      priv->workspace_bins = g_list_delete_link (priv->workspace_bins,
                                                 priv->workspace_bins);
    }

  clutter_actor_queue_relayout (CLUTTER_ACTOR (preview));
}

static void
champlain_viewport_init (ChamplainViewport *self)
{
  self->priv = GET_PRIVATE (self);

  self->priv->sync_adjustments = TRUE;

  self->priv->child = NULL;
  self->priv->content_group = clutter_group_new ();
  clutter_actor_set_parent (CLUTTER_ACTOR (self->priv->content_group), CLUTTER_ACTOR (self));
  clutter_actor_queue_relayout (CLUTTER_ACTOR (self));

  g_signal_connect (self, "notify::clip",
      G_CALLBACK (clip_notify_cb), self);
}

/**
 * clutter_bind_constraint_set_offset:
 * @constraint: a #ClutterBindConstraint
 * @offset: the offset to apply, in pixels
 *
 * Sets the offset to be applied to the constraint
 *
 * Since: 1.4
 */
void
clutter_bind_constraint_set_offset (ClutterBindConstraint *constraint,
                                    gfloat                 offset)
{
  g_return_if_fail (CLUTTER_IS_BIND_CONSTRAINT (constraint));

  if (fabs (constraint->offset - offset) < 0.00001f)
    return;

  constraint->offset = offset;

  if (constraint->actor != NULL)
    clutter_actor_queue_relayout (constraint->actor);

  g_object_notify_by_pspec (G_OBJECT (constraint), obj_props[PROP_OFFSET]);
}

/**
 * clutter_bind_constraint_set_coordinate:
 * @constraint: a #ClutterBindConstraint
 * @coordinate: the coordinate to bind
 *
 * Sets the coordinate to bind in the constraint
 *
 * Since: 1.4
 */
void
clutter_bind_constraint_set_coordinate (ClutterBindConstraint *constraint,
                                        ClutterBindCoordinate  coordinate)
{
  g_return_if_fail (CLUTTER_IS_BIND_CONSTRAINT (constraint));

  if (constraint->coordinate == coordinate)
    return;

  constraint->coordinate = coordinate;

  if (constraint->actor != NULL)
    clutter_actor_queue_relayout (constraint->actor);

  g_object_notify_by_pspec (G_OBJECT (constraint), obj_props[PROP_COORDINATE]);
}

/**
 * clutter_path_constraint_set_offset:
 * @constraint: a #ClutterPathConstraint
 * @offset: the offset along the path
 *
 * Sets the offset along the #ClutterPath used by @constraint.
 *
 * Since: 1.6
 */
void
clutter_path_constraint_set_offset (ClutterPathConstraint *constraint,
                                    gfloat                 offset)
{
  g_return_if_fail (CLUTTER_IS_PATH_CONSTRAINT (constraint));

  if (constraint->offset == offset)
    return;

  constraint->offset = offset;

  if (constraint->actor != NULL)
    clutter_actor_queue_relayout (constraint->actor);

  _clutter_notify_by_pspec (G_OBJECT (constraint), path_properties[PROP_OFFSET]);
}

static void
clutter_constraint_notify (GObject    *gobject,
                           GParamSpec *pspec)
{
  if (strcmp (pspec->name, "enabled") == 0)
    {
      ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject);
      ClutterActor *actor = clutter_actor_meta_get_actor (meta);

      if (actor != NULL)
        clutter_actor_queue_relayout (actor);
    }

  if (G_OBJECT_CLASS (clutter_constraint_parent_class)->notify != NULL)
    G_OBJECT_CLASS (clutter_constraint_parent_class)->notify (gobject, pspec);
}