void
mx_viewport_set_origin (MxViewport *viewport,
gfloat x,
gfloat y,
gfloat z)
{
MxViewportPrivate *priv;
g_return_if_fail (MX_IS_VIEWPORT (viewport));
priv = viewport->priv;
g_object_freeze_notify (G_OBJECT (viewport));
if (x != priv->x)
{
priv->x = x;
g_object_notify (G_OBJECT (viewport), "x-origin");
if (priv->hadjustment)
mx_adjustment_set_value (priv->hadjustment,
(float)(x));
}
if (y != priv->y)
{
priv->y = y;
g_object_notify (G_OBJECT (viewport), "y-origin");
if (priv->vadjustment)
mx_adjustment_set_value (priv->vadjustment,
(float)(y));
}
if (z != priv->z)
{
priv->z = z;
g_object_notify (G_OBJECT (viewport), "z-origin");
}
g_object_thaw_notify (G_OBJECT (viewport));
clutter_actor_queue_redraw (CLUTTER_ACTOR (viewport));
}
static void
interpolation_completed_cb (ClutterTimeline *timeline,
MxAdjustment *adjustment)
{
MxAdjustmentPrivate *priv = adjustment->priv;
if (priv->elastic && priv->clamp_value)
{
if (clutter_timeline_get_direction (priv->interpolation) ==
CLUTTER_TIMELINE_FORWARD)
{
clutter_timeline_set_direction (priv->interpolation,
CLUTTER_TIMELINE_BACKWARD);
clutter_timeline_set_duration (priv->interpolation, 250);
clutter_timeline_rewind (priv->interpolation);
if (priv->new_position < priv->lower)
{
priv->old_position = priv->lower;
clutter_timeline_start (priv->interpolation);
}
else if (priv->new_position > (priv->upper - priv->page_size))
{
priv->old_position = priv->upper - priv->page_size;
clutter_timeline_start (priv->interpolation);
}
}
else
{
stop_interpolation (adjustment);
mx_adjustment_set_value (adjustment, priv->old_position);
}
}
else
{
stop_interpolation (adjustment);
mx_adjustment_set_value (adjustment, priv->new_position);
}
g_signal_emit (adjustment, signals[INTERPOLATION_COMPLETED], 0);
}
/**
* mx_adjustment_interpolate:
* @adjustment: A #MxAdjustment
* @value: A #gdouble
* @duration: duration in milliseconds
* @mode: A #ClutterAnimationMode
*
* Interpolate #MxAdjustment:value to the new value specified by @value, using
* the mode and duration given.
*/
void
mx_adjustment_interpolate (MxAdjustment *adjustment,
gdouble value,
guint duration,
gulong mode)
{
MxAdjustmentPrivate *priv = adjustment->priv;
g_return_if_fail (isfinite (value));
if (duration <= 1)
{
stop_interpolation (adjustment);
mx_adjustment_set_value (adjustment, value);
return;
}
priv->old_position = priv->value;
priv->new_position = value;
if (!priv->interpolation)
{
priv->interpolation = clutter_timeline_new (duration);
g_signal_connect (priv->interpolation,
"new-frame",
G_CALLBACK (interpolation_new_frame_cb),
adjustment);
g_signal_connect (priv->interpolation,
"completed",
G_CALLBACK (interpolation_completed_cb),
adjustment);
}
else
{
/* Extend the animation if it gets interrupted, otherwise frequent calls
* to this function will end up with no advancements until the calls
* finish (as the animation never gets a chance to start).
*/
clutter_timeline_set_direction (priv->interpolation,
CLUTTER_TIMELINE_FORWARD);
clutter_timeline_rewind (priv->interpolation);
clutter_timeline_set_duration (priv->interpolation, duration);
}
if (priv->interpolate_alpha)
g_object_unref (priv->interpolate_alpha);
priv->interpolate_alpha = clutter_alpha_new_full (priv->interpolation,
mode);
clutter_timeline_start (priv->interpolation);
}
static void
mx_adjustment_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
MxAdjustment *adj = MX_ADJUSTMENT (gobject);
switch (prop_id)
{
case PROP_LOWER:
mx_adjustment_set_lower (adj, g_value_get_double (value));
break;
case PROP_UPPER:
mx_adjustment_set_upper (adj, g_value_get_double (value));
break;
case PROP_VALUE:
mx_adjustment_set_value (adj, g_value_get_double (value));
break;
case PROP_STEP_INC:
mx_adjustment_set_step_increment (adj, g_value_get_double (value));
break;
case PROP_PAGE_INC:
mx_adjustment_set_page_increment (adj, g_value_get_double (value));
break;
case PROP_PAGE_SIZE:
mx_adjustment_set_page_size (adj, g_value_get_double (value));
break;
case PROP_ELASTIC:
mx_adjustment_set_elastic (adj, g_value_get_boolean (value));
break;
case PROP_CLAMP_VALUE:
mx_adjustment_set_clamp_value (adj, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
static void
move_slider (MxScrollBar *bar,
gfloat x,
gfloat y)
{
MxScrollBarPrivate *priv = bar->priv;
gdouble position, lower, upper, page_size;
gfloat ux, uy, pos, size;
if (!priv->adjustment)
return;
if (!clutter_actor_transform_stage_point (priv->trough, x, y, &ux, &uy))
return;
if (priv->orientation == MX_ORIENTATION_VERTICAL)
size = clutter_actor_get_height (priv->trough)
- clutter_actor_get_height (priv->handle);
else
size = clutter_actor_get_width (priv->trough)
- clutter_actor_get_width (priv->handle);
if (size == 0)
return;
if (priv->orientation == MX_ORIENTATION_VERTICAL)
pos = uy - priv->y_origin;
else
pos = ux - priv->x_origin;
pos = CLAMP (pos, 0, size);
mx_adjustment_get_values (priv->adjustment,
NULL,
&lower,
&upper,
NULL,
NULL,
&page_size);
position = ((pos / size)
* (upper - lower - page_size))
+ lower;
mx_adjustment_set_value (priv->adjustment, position);
}
/**
* mx_adjustment_set_values:
* @adjustment: A #MxAdjustment
* @value: A #gdouble
* @lower: A #gdouble
* @upper: A #gdouble
* @step_increment: A #gdouble
* @page_increment: A #gdouble
* @page_size: A #gdouble
*
* Set the various properties of MxAdjustment.
*
*/
void
mx_adjustment_set_values (MxAdjustment *adjustment,
gdouble value,
gdouble lower,
gdouble upper,
gdouble step_increment,
gdouble page_increment,
gdouble page_size)
{
MxAdjustmentPrivate *priv;
gboolean emit_changed = FALSE;
g_return_if_fail (MX_IS_ADJUSTMENT (adjustment));
g_return_if_fail (page_size >= 0 && page_size <= G_MAXDOUBLE);
g_return_if_fail (step_increment >= 0 && step_increment <= G_MAXDOUBLE);
g_return_if_fail (page_increment >= 0 && page_increment <= G_MAXDOUBLE);
priv = adjustment->priv;
emit_changed = FALSE;
g_object_freeze_notify (G_OBJECT (adjustment));
emit_changed |= _mx_adjustment_set_lower (adjustment, lower);
emit_changed |= _mx_adjustment_set_upper (adjustment, upper);
emit_changed |= _mx_adjustment_set_step_increment (adjustment,
step_increment);
emit_changed |= _mx_adjustment_set_page_increment (adjustment,
page_increment);
emit_changed |= _mx_adjustment_set_page_size (adjustment, page_size);
if (value != priv->value)
{
mx_adjustment_set_value (adjustment, value);
emit_changed = TRUE;
}
if (emit_changed)
mx_adjustment_emit_changed (adjustment);
g_object_thaw_notify (G_OBJECT (adjustment));
}
static void
mex_media_controls_replace_content (MexMediaControls *self,
MexContent *content)
{
MexPlayer *player;
MxScrollable *related_box;
MxAdjustment *adjustment;
gdouble upper;
MexMediaControlsPrivate *priv = self->priv;
if (priv->content == content)
return;
player = mex_player_get_default ();
mex_content_view_set_content (MEX_CONTENT_VIEW (player), content);
if (priv->content)
g_object_unref (priv->content);
priv->content = g_object_ref_sink (content);
mex_media_controls_update_header (self);
mex_content_view_set_content (MEX_CONTENT_VIEW (priv->queue_button),
content);
mex_push_focus ((MxFocusable*) clutter_script_get_object (priv->script,
"play-pause-button"));
related_box = (MxScrollable *)clutter_script_get_object (priv->script,
"related-box");
mx_scrollable_get_adjustments (MX_SCROLLABLE (related_box),
&adjustment, NULL);
mx_adjustment_get_values (adjustment, NULL, NULL, &upper,
NULL, NULL, NULL);
mx_adjustment_set_value (adjustment, upper);
mx_scrollable_set_adjustments (MX_SCROLLABLE (related_box),
adjustment,
NULL);
}
static void
interpolation_new_frame_cb (ClutterTimeline *timeline,
guint msecs,
MxAdjustment *adjustment)
{
gdouble new_value;
MxAdjustmentPrivate *priv = adjustment->priv;
new_value = priv->old_position +
(priv->new_position - priv->old_position) *
clutter_timeline_get_progress (priv->interpolation);
priv->interpolation = NULL;
mx_adjustment_set_value (adjustment, new_value);
priv->interpolation = timeline;
/* Stop the interpolation if we've reached the end of the adjustment */
if (!priv->elastic && priv->clamp_value &&
((new_value < priv->lower) ||
(new_value > (priv->upper - priv->page_size))))
stop_interpolation (adjustment);
}
