static void
add_float_prop_base (ClutterActor *table,
const char *name,
FloatProp *prop,
float value)
{
int table_y = mx_table_get_row_count (MX_TABLE (table));
ClutterActor *label;
ClutterActor *slider;
label = mx_label_new_with_text (name);
mx_table_add_actor (MX_TABLE (table), label, table_y, 0);
slider = mx_slider_new ();
mx_table_add_actor (MX_TABLE (table), slider, table_y, 1);
prop->label = mx_label_new ();
mx_table_add_actor (MX_TABLE (table), prop->label, table_y, 2);
mx_slider_set_value (MX_SLIDER (slider),
(value - prop->min) / (prop->max - prop->min));
update_float_prop_label (prop, value);
g_signal_connect_data (slider, "notify::value",
G_CALLBACK (float_prop_value_cb),
prop,
(GClosureNotify) float_prop_free,
0);
}
static void
mx_slider_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxSlider *self = MX_SLIDER (actor);
MxSliderPrivate *priv = self->priv;
MxPadding padding;
ClutterActorClass *actor_class;
ClutterActorBox bar_box;
ClutterActorBox trough_box;
guint handle_width_2;
actor_class = CLUTTER_ACTOR_CLASS (mx_slider_parent_class);
actor_class->allocate (actor, box, flags);
if (box == NULL)
{
clutter_actor_get_allocation_box (CLUTTER_ACTOR (self), &bar_box);
box = &bar_box;
}
handle_width_2 = priv->handle_width >> 1;
mx_widget_get_padding (MX_WIDGET (self), &padding);
/* save the min/max position of the middle of the handle */
priv->handle_middle_start = padding.left + handle_width_2 + 1;
priv->handle_middle_end = box->x2 - box->x1 - padding.right -
handle_width_2 - 1;
if (priv->trough_height < 0)
{
/* trough-height has not been specified, take the whole height */
trough_box.x1 = padding.left;
trough_box.y1 = padding.top;
trough_box.x2 = (box->x2 - box->x1) - padding.right;
trough_box.y2 = (box->y2 - box->y1) - padding.bottom;
}
else
{
trough_box.x1 = padding.left;
trough_box.y1 = (int) ((box->y2 - box->y1 - padding.bottom - padding.top -
priv->trough_height) / 2);
trough_box.x2 = (box->x2 - box->x1) - padding.right;
trough_box.y2 = trough_box.y1 + priv->trough_height;
}
clutter_actor_allocate (priv->trough_bg, &trough_box, flags);
/* save trough_box.y1 and trough_box.y2 so we don't have the duplicate
* the logic above in ::allocate_fill() */
priv->trough_box_y1 = trough_box.y1;
priv->trough_box_y2 = trough_box.y2;
mx_slider_allocate_fill_handle (self, box, flags);
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
static void
mex_media_controls_notify_download_cb (ClutterMedia *media,
gdouble start,
gdouble stop,
MexMediaControls *self)
{
MexMediaControlsPrivate *priv = self->priv;
mx_slider_set_buffer_value (MX_SLIDER (priv->slider), stop);
}
static void
mex_music_player_slider_notify (MxSlider *slider,
GParamSpec *pspec,
MexMusicPlayer *player)
{
MexMusicPlayerPrivate *priv = player->priv;
clutter_media_set_progress (priv->player,
mx_slider_get_value (MX_SLIDER (priv->slider)));
}
void on_button_clicked(MxButton *button, gpointer user_data)
{
Assistant *assistant = (Assistant *) user_data;
(void) assistant; // unused
(void) button; // unused
g_print("clicked\n");
if (assistant->ready_)
{
g_print("slider value: %f\n", mx_slider_get_value(MX_SLIDER(assistant->slider)));
}
}
static void
slider_value_changed_cb (MxSlider *slider,
GParamSpec *pspec,
MexMediaControls *controls)
{
MexMediaControlsPrivate *priv = controls->priv;
if (priv->media)
clutter_media_set_progress (priv->media,
mx_slider_get_value (MX_SLIDER (priv->slider)));
}
static void
mx_slider_pick (ClutterActor *actor,
const ClutterColor *pick_color)
{
MxSlider *self = MX_SLIDER (actor);
MxSliderPrivate *priv = self->priv;
/* Chaining up won't draw the media bar outline as it's not set reactive
* by default */
CLUTTER_ACTOR_CLASS (mx_slider_parent_class)->pick (actor, pick_color);
clutter_actor_paint (priv->trough_bg);
clutter_actor_paint (priv->handle);
}
static void
add_color_prop_base (ClutterActor *table,
const char *name,
ColorProp *prop,
const ClutterColor *value)
{
int table_y = mx_table_get_row_count (MX_TABLE (table));
ClutterActor *label;
static const char *color_names[] = { "red", "green", "blue" };
int i;
label = mx_label_new_with_text (name);
mx_table_add_actor (MX_TABLE (table), label, table_y, 0);
prop->rect = clutter_rectangle_new ();
clutter_rectangle_set_color (CLUTTER_RECTANGLE (prop->rect), value);
clutter_actor_set_size (prop->rect, 20, 0);
mx_table_add_actor (MX_TABLE (table), prop->rect, table_y++, 1);
for (i = 0; i < G_N_ELEMENTS (color_names); i++)
{
ClutterActor *slider;
char *label_name = g_strconcat (name, " ", color_names[i], NULL);
ColorPropComp *prop_comp = g_slice_new (ColorPropComp);
label = mx_label_new_with_text (label_name);
mx_table_add_actor (MX_TABLE (table), label, table_y, 0);
g_free (label_name);
slider = mx_slider_new ();
mx_table_add_actor (MX_TABLE (table), slider, table_y, 1);
mx_slider_set_value (MX_SLIDER (slider),
((guint8 *) value)[i] / 255.0f);
prop_comp->comp_num = i;
prop_comp->prop = prop;
prop_comp->label = mx_label_new ();
mx_table_add_actor (MX_TABLE (table), prop_comp->label, table_y, 2);
update_prop_comp_label (prop_comp, ((guint8 *) value)[i]);
g_signal_connect_data (slider, "notify::value",
G_CALLBACK (color_prop_value_cb),
prop_comp,
(GClosureNotify) color_prop_comp_free,
0);
table_y++;
}
}
static gboolean
mx_slider_key_press_event (ClutterActor *actor,
ClutterKeyEvent *event)
{
gdouble value;
value = mx_slider_get_value (MX_SLIDER (actor));
switch (event->keyval)
{
case CLUTTER_Left :
mx_slider_set_value (MX_SLIDER (actor), MAX (value - 0.1, 0));
return TRUE;
case CLUTTER_Right :
mx_slider_set_value (MX_SLIDER (actor), MIN (value + 0.1, 1));
return TRUE;
default:
break;
}
return FALSE;
}
static void
mx_slider_dispose (GObject *object)
{
MxSlider *self = MX_SLIDER (object);
MxSliderPrivate *priv = self->priv;
if (priv->capture_handler && priv->trough)
{
ClutterActor *stage;
stage = clutter_actor_get_stage (priv->trough);
g_signal_handler_disconnect (stage, priv->capture_handler);
priv->capture_handler = 0;
}
G_OBJECT_CLASS (mx_slider_parent_class)->dispose (object);
}
static void
mex_media_controls_notify_progress_cb (ClutterMedia *media,
GParamSpec *pspec,
MexMediaControls *self)
{
MexMediaControlsPrivate *priv = self->priv;
MxLabel *label;
gchar *text;
gdouble length, progress_s;
gfloat progress;
gint len_h, len_m, len_s, pos_h, pos_m, pos_s;
if (priv->show_description)
return;
progress = clutter_media_get_progress (media);
length = clutter_media_get_duration (media);
len_h = length / 3600;
len_m = (length - (len_h * 3600)) / 60;
len_s = (length - (len_h * 3600) - (len_m * 60));
progress_s = length * progress;
pos_h = progress_s / 3600;
pos_m = (progress_s - (pos_h * 3600)) / 60;
pos_s = (progress_s - (pos_h * 3600) - (pos_m * 60));
g_signal_handlers_block_by_func (priv->slider, slider_value_changed_cb, self);
mx_slider_set_value (MX_SLIDER (priv->slider), progress);
g_signal_handlers_unblock_by_func (priv->slider, slider_value_changed_cb,
self);
if (len_h > 0)
text = g_strdup_printf ("%02d:%02d:%02d / %02d:%02d:%02d",
pos_h, pos_m, pos_s, len_h, len_m, len_s);
else
text = g_strdup_printf ("%02d:%02d / %02d:%02d",
pos_m, pos_s, len_m, len_s);
label = (MxLabel*) clutter_script_get_object (priv->script, "progress-label");
mx_label_set_text (label, text);
g_free (text);
}
static void
update_volume_slider (MpdVolumeTile *self)
{
MpdVolumeTilePrivate *priv = GET_PRIVATE (self);
double volume;
double value;
g_signal_handlers_disconnect_by_func (priv->volume_slider,
_volume_slider_value_notify_cb,
self);
volume = gvc_mixer_stream_get_volume (priv->sink);
value = volume / PA_VOLUME_NORM;
mx_slider_set_value (MX_SLIDER (priv->volume_slider), value);
g_signal_connect (priv->volume_slider, "notify::value",
G_CALLBACK (_volume_slider_value_notify_cb), self);
}
static void
mx_slider_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
MxPadding padding;
MxSliderPrivate *priv = MX_SLIDER (actor)->priv;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* Add on the size of the trough/handle + padding */
if (min_height_p)
*min_height_p = MAX (priv->handle_height, priv->trough_height) +
padding.top + padding.bottom;
if (nat_height_p)
*nat_height_p = MAX (priv->handle_height, priv->trough_height) +
padding.top + padding.bottom;
}
static void
mx_slider_paint (ClutterActor *actor)
{
MxSlider *self = MX_SLIDER (actor);
MxSliderPrivate *priv = self->priv;
CLUTTER_ACTOR_CLASS (mx_slider_parent_class)->paint (actor);
clutter_actor_paint (priv->trough_bg);
clutter_actor_paint (priv->trough);
if (priv->buffer_value)
clutter_actor_paint (priv->buffer);
if (priv->value)
clutter_actor_paint (priv->fill);
clutter_actor_paint (priv->handle);
}
static void
mx_slider_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
MxSliderPrivate *priv = MX_SLIDER (actor)->priv;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* Set the size of the handle + padding */
if (min_width_p)
*min_width_p = priv->handle_width + padding.left + padding.right;
/* Set the preferred size as some arbitrary value larger than the handle
* width. This ensures the slider can actually move!
*/
if (nat_width_p)
*nat_width_p = (priv->handle_width * 4) + padding.left + padding.right;
}
static void
mex_music_player_update_progress (MexMusicPlayer *player)
{
MexMusicPlayerPrivate *priv = player->priv;
ClutterActor *label, *slider;
gchar *text;
gdouble progress, duration;
progress = clutter_media_get_progress (priv->player);
duration = clutter_media_get_duration (priv->player);
label = mex_script_get_actor (priv->script, "progress-label");
slider = mex_script_get_actor (priv->script, "progress-slider");
g_signal_handler_block (slider, priv->slider_notify_id);
mx_slider_set_value (MX_SLIDER (slider), progress);
g_signal_handler_unblock (slider, priv->slider_notify_id);
text = mex_metadata_utils_create_progress_string (progress, duration);
mx_label_set_text (MX_LABEL (label), text);
g_free (text);
}
static void
mx_slider_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
MxSlider *self = MX_SLIDER (object);
switch (property_id)
{
case PROP_VALUE:
mx_slider_set_value (self, g_value_get_double (value));
break;
case PROP_BUFFER_VALUE:
mx_slider_set_buffer_value (self, g_value_get_double (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
static void
update_stream_volume (MpdVolumeTile *self)
{
MpdVolumeTilePrivate *priv = GET_PRIVATE (self);
double progress;
pa_volume_t volume;
g_signal_handlers_disconnect_by_func (priv->sink,
_stream_volume_notify_cb,
self);
progress = mx_slider_get_value (MX_SLIDER (priv->volume_slider));
volume = progress * PA_VOLUME_NORM;
if (gvc_mixer_stream_set_volume (priv->sink, volume))
gvc_mixer_stream_push_volume (priv->sink);
else
g_warning ("%s() failed", __FUNCTION__);
g_signal_connect (priv->sink, "notify::volume",
G_CALLBACK (_stream_volume_notify_cb), self);
}
