static void
mx_progress_bar_allocate_fill (MxProgressBar *self,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
ClutterActorBox box_data;
MxProgressBarPrivate *priv = self->priv;
if (!box)
{
clutter_actor_get_allocation_box (CLUTTER_ACTOR (self), &box_data);
box = &box_data;
}
if (priv->progress)
{
ClutterActorBox child_box;
MxPadding padding;
mx_widget_get_padding (MX_WIDGET (self), &padding);
child_box.x1 = padding.left;
child_box.y1 = padding.top;
child_box.y2 = (box->y2 - box->y1) - padding.bottom;
child_box.x2 = ((box->x2 - box->x1 - padding.left - padding.right) *
priv->progress) + padding.left;
clutter_actor_allocate (priv->fill, &child_box, flags);
}
}
static void
mx_progress_bar_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
MxProgressBarPrivate *priv = MX_PROGRESS_BAR (actor)->priv;
gfloat height;
clutter_actor_get_preferred_width (priv->fill,
for_height,
min_width_p,
nat_width_p);
clutter_actor_get_preferred_height (priv->fill,
-1,
&height,
NULL);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_width_p)
*min_width_p += padding.left + padding.right;
/* Add an arbitrary amount to the width for preferred width, so that the
* indicator is visible and can display some values */
if (nat_width_p)
*nat_width_p += padding.left + padding.right + height * 4;
}
static void
mx_label_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
MxLabelPrivate *priv = MX_LABEL (actor)->priv;
MxPadding padding = { 0, };
mx_widget_get_padding (MX_WIDGET (actor), &padding);
for_height -= padding.top + padding.bottom;
clutter_actor_get_preferred_width (priv->label, for_height,
min_width_p,
natural_width_p);
/* If we're fading out, make sure our minimum width is zero */
if (priv->fade_out && min_width_p)
*min_width_p = 0;
if (min_width_p)
*min_width_p += padding.left + padding.right;
if (natural_width_p)
*natural_width_p += padding.left + padding.right;
}
static void
mex_volume_control_init (MexVolumeControl *self)
{
MexVolumeControlPrivate *priv = self->priv = VOLUME_CONTROL_PRIVATE (self);
gchar *new_style_class;
MexPlayer *player;
MexMusicPlayer *music;
player = mex_player_get_default ();
priv->media = mex_player_get_clutter_media (player);
music = mex_music_player_get_default ();
priv->music = mex_music_player_get_clutter_media (music);
priv->volume = mx_button_new ();
mx_widget_set_disabled (MX_WIDGET (priv->volume), TRUE);
priv->vol_value = clutter_media_get_audio_volume (priv->media);
/* The media sound can also be changed from another process changint the
* stream audio with pulse audio, adjust the volume on those changes */
g_signal_connect (priv->media, "notify::audio-volume",
G_CALLBACK (on_audio_volume_changed), self);
g_signal_connect (priv->music, "notify::audio-volume",
G_CALLBACK (on_audio_volume_changed), self);
new_style_class = g_strdup_printf ("volume-%.0f", priv->vol_value * 10);
mx_stylable_set_style_class (MX_STYLABLE (priv->volume), new_style_class);
g_free (new_style_class);
clutter_actor_add_child (CLUTTER_ACTOR (self), priv->volume);
}
static gboolean
mnb_launcher_button_key_release_event (ClutterActor *actor,
ClutterKeyEvent *event)
{
if (event->keyval == CLUTTER_KEY_Return ||
event->keyval == CLUTTER_KEY_KP_Enter ||
event->keyval == CLUTTER_KEY_ISO_Enter)
{
MnbLauncherButton *self = MNB_LAUNCHER_BUTTON (actor);
if (!self->priv->is_pressed)
return FALSE;
clutter_ungrab_keyboard ();
self->priv->is_pressed = FALSE;
g_signal_emit (self, _signals[ACTIVATED], 0);
mx_stylable_set_style_pseudo_class (MX_STYLABLE (self), NULL);
mx_widget_hide_tooltip (MX_WIDGET (self));
return TRUE;
}
return FALSE;
}
static void
mpl_panel_background_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MplPanelBackgroundPrivate *priv = MPL_PANEL_BACKGROUND (actor)->priv;
#if 0
ClutterActor *border;
border = mx_widget_get_border_image (MX_WIDGET (actor));
/*
* We need to use different background asset based on the size allocated to us
* -- basically, the panel cannot be smaller than the size of the borders of
* its border image (see MB#702), so if it is smaller than the current asset
* allows, we change the asset to simpler one.
*
* The code here assumes that we either have no name, or are called
* 'too-small', but since this is a private widget of libmeego-panel, we can
* enforce this assumption.
*/
if (border)
{
const gchar *name = clutter_actor_get_name (actor);
gboolean too_small = FALSE;
/*
* Get the dimensions of the base texture (we are guaranteed to be called
* first with name == NULL, so this works).
*/
if (!priv->base_geom_known && !name)
{
mx_texture_frame_get_border_values (/*MX_TEXTURE_FRAME*/ (border),
&priv->base_t,
&priv->base_r,
&priv->base_b,
&priv->base_l);
priv->base_geom_known = TRUE;
}
if (priv->base_l + priv->base_r > box->x2 - box->x1 ||
priv->base_t + priv->base_b > box->y2 - box->y1)
{
too_small = TRUE;
}
if (!name && too_small)
{
clutter_actor_set_name (actor, "too-small");
}
else if (name && !too_small)
{
clutter_actor_set_name (actor, NULL);
}
}
#endif //DV
CLUTTER_ACTOR_CLASS (
mpl_panel_background_parent_class)->allocate (actor, box, flags);
}
static void
mnb_fancy_bin_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxPadding padding;
ClutterActorBox child_box;
MnbFancyBinPrivate *priv = MNB_FANCY_BIN (actor)->priv;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (priv->real_child)
clutter_actor_allocate_preferred_size (priv->real_child, flags);
child_box.x1 = padding.left;
child_box.x2 = box->x2 - box->x1 - padding.right;
child_box.y1 = padding.top;
child_box.y2 = box->y2 - box->y1 - padding.bottom;
if (priv->child)
clutter_actor_allocate (priv->child, &child_box, flags);
if (priv->clone)
clutter_actor_allocate (priv->clone, &child_box, flags);
CLUTTER_ACTOR_CLASS (mnb_fancy_bin_parent_class)->
allocate (actor, box, flags);
}
static void
mnb_fancy_bin_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
MxPadding padding;
MnbFancyBinPrivate *priv = MNB_FANCY_BIN (actor)->priv;
if (min_height_p)
*min_height_p = 0;
if (nat_height_p)
*nat_height_p = 0;
if (priv->real_child)
clutter_actor_get_preferred_height (priv->real_child,
for_width,
min_height_p,
nat_height_p);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_height_p)
*min_height_p += padding.top + padding.bottom;
if (nat_height_p)
*nat_height_p += padding.top + padding.bottom;
}
static void
mx_toggle_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *pref_height_p)
{
ClutterActor *background;
gfloat pref_h;
background = mx_widget_get_background_image (MX_WIDGET (actor));
if (!background)
{
if (min_height_p)
*min_height_p = 0;
if (pref_height_p)
*pref_height_p = 0;
return;
}
clutter_actor_get_preferred_height (background, -1, NULL, &pref_h);
if (min_height_p)
*min_height_p = pref_h;
if (pref_height_p)
*pref_height_p = pref_h;
}
static gboolean
on_trough_bg_button_press_event (ClutterActor *actor,
ClutterButtonEvent *event,
MxSlider *self)
{
MxSliderPrivate *priv = self->priv;
ClutterActor *stage;
if (event->button != 1)
return FALSE;
if (mx_widget_get_disabled (MX_WIDGET (actor)))
return FALSE;
move_handle (self, event->x, event->y);
stage = clutter_actor_get_stage (priv->handle);
/* Turn off picking for motion events */
clutter_stage_set_motion_events_enabled (CLUTTER_STAGE (stage), FALSE);
priv->capture_handler =
g_signal_connect_after (stage,
"captured-event",
G_CALLBACK (on_handle_capture_event),
self);
return TRUE;
}
static void
mx_notebook_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxNotebookPrivate *priv = MX_NOTEBOOK (actor)->priv;
GList *l;
MxPadding padding;
ClutterActorBox childbox;
CLUTTER_ACTOR_CLASS (mx_notebook_parent_class)->allocate (actor, box, flags);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
childbox.x1 = 0 + padding.left;
childbox.x2 = box->x2 - box->x1 - padding.right;
childbox.y1 = 0 + padding.top;
childbox.y2 = box->y2 - box->y1 - padding.bottom;
for (l = priv->children; l; l = l->next)
{
ClutterActor *child;
child = CLUTTER_ACTOR (l->data);
if (CLUTTER_ACTOR_IS_VISIBLE (l->data))
clutter_actor_allocate (child, &childbox, flags);
}
}
static void
mex_column_pick (ClutterActor *actor, const ClutterColor *color)
{
GList *c;
gdouble value;
MxPadding padding;
ClutterActorBox box;
MexColumn *self = MEX_COLUMN (actor);
MexColumnPrivate *priv = self->priv;
CLUTTER_ACTOR_CLASS (mex_column_parent_class)->pick (actor, color);
/* Don't pick children when we don't have focus */
if (!priv->has_focus)
return;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
clutter_actor_get_allocation_box (actor, &box);
if (priv->adjustment)
value = priv->adjustment_value;
else
value = 0;
cogl_clip_push_rectangle (padding.left,
padding.top + value,
box.x2 - box.x1 - padding.right,
box.y2 - box.y1 - padding.bottom + value);
for (c = priv->children; c; c = c->next)
clutter_actor_paint (c->data);
cogl_clip_pop ();
}
static void
mex_epg_grid_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MexEpgGrid *grid = MEX_EPG_GRID (actor);
MexEpgGridPrivate *priv = grid->priv;
MxPadding padding;
GTimeSpan diff;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (priv->first_date == NULL || priv->last_date == NULL)
diff = 0;
else
diff = g_date_time_difference (priv->last_date, priv->first_date);
if (min_width_p)
*min_width_p = 0;
if (nat_width_p)
*nat_width_p = time_span_to_pixels (grid, diff) + padding.left +
padding.right;
}
static void
mex_column_paint (ClutterActor *actor)
{
GList *c;
MxPadding padding;
ClutterActorBox box;
MexColumn *self = MEX_COLUMN (actor);
MexColumnPrivate *priv = self->priv;
CLUTTER_ACTOR_CLASS (mex_column_parent_class)->paint (actor);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
clutter_actor_get_allocation_box (actor, &box);
cogl_clip_push_rectangle (padding.left,
padding.top + priv->adjustment_value,
box.x2 - box.x1 - padding.right,
box.y2 - box.y1 - padding.bottom +
priv->adjustment_value);
for (c = priv->children; c; c = c->next)
{
/* skip the current focus and paint it last*/
if (priv->current_focus != c->data)
clutter_actor_paint (c->data);
}
/* paint the current focused actor last to ensure any shadow is drawn
* on top of other items */
if (priv->current_focus)
clutter_actor_paint (priv->current_focus);
cogl_clip_pop ();
}
static void
mx_frame_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height,
gfloat *pref_height)
{
MxFramePrivate *priv = ((MxFrame *) actor)->priv;
MxPadding padding;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_height)
*min_height = 0;
if (pref_height)
*pref_height = 0;
if (priv->child)
{
clutter_actor_get_preferred_height (priv->child,
for_width - padding.left - padding.right,
min_height, pref_height);
}
if (min_height)
*min_height += padding.top + padding.bottom;
if (pref_height)
*pref_height += padding.top + padding.bottom;
}
/**
* mx_bin_allocate_child:
* @bin: An #MxBin
* @box: The allocation box of the parent actor.
* @flags: #ClutterAllocationFlags, usually provided by the.
* clutter_actor_allocate function.
*
* Allocates the child of an #MxBin using the width and height from @box.
* This function should usually only be called by subclasses of #MxBin.
*
* This function can be used to allocate the child of an #MxBin if no special
* allocation requirements are needed. It is similar to
* #mx_allocate_align_fill, except that it reads the alignment, padding and
* fill values from the #MxBin, and will call #clutter_actor_allocate on the
* child.
*
*/
void
mx_bin_allocate_child (MxBin *bin,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxBinPrivate *priv;
g_return_if_fail (MX_IS_BIN (bin));
priv = bin->priv;
if (priv->child)
{
MxPadding padding;
ClutterActorBox allocation = { 0, };
mx_widget_get_padding (MX_WIDGET (bin), &padding);
allocation.x1 = padding.left;
allocation.x2 = box->x2 - box->x1 - padding.right;
allocation.y1 = padding.top;
allocation.y2 = box->y2 - box->y1 - padding.bottom;
mx_allocate_align_fill (priv->child,
&allocation,
priv->x_align,
priv->y_align,
priv->x_fill,
priv->y_fill);
clutter_actor_allocate (priv->child, &allocation, flags);
}
}
static void
mx_combo_box_update_menu (MxComboBox *box)
{
MxComboBoxPrivate *priv = box->priv;
GSList *l;
gint index;
MxMenu *menu;
menu = mx_widget_get_menu (MX_WIDGET (box));
if (!menu)
return;
mx_menu_remove_all (menu);
for (index = 0, l = priv->actions; l; l = g_slist_next (l), index++)
{
MxAction *action;
action = (MxAction *)l->data;
g_object_set_data ((GObject*) action, "index", GINT_TO_POINTER (index));
mx_menu_add_action (menu, action);
}
/* queue a relayout so the combobox size can match the new menu */
clutter_actor_queue_relayout ((ClutterActor*) box);
}
static void
mx_combo_box_init (MxComboBox *self)
{
MxComboBoxPrivate *priv;
ClutterActor *menu;
priv = self->priv = COMBO_BOX_PRIVATE (self);
priv->spacing = 8;
priv->label = clutter_text_new ();
clutter_actor_add_child ((ClutterActor*) self, priv->label);
menu = mx_menu_new ();
mx_widget_set_menu (MX_WIDGET (self), MX_MENU (menu));
g_signal_connect (menu, "action-activated",
G_CALLBACK (mx_combo_box_action_activated_cb),
self);
g_signal_connect (self, "style-changed",
G_CALLBACK (mx_combo_box_style_changed), NULL);
clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE);
g_signal_connect (self, "notify::disabled",
G_CALLBACK (mx_combo_box_disable_notify_cb), NULL);
}
static gboolean
mx_toggle_handle_button_release_event (ClutterActor *actor,
ClutterButtonEvent *event,
MxToggle *toggle)
{
ClutterActorBox box;
if (mx_widget_get_disabled (MX_WIDGET (toggle)))
return FALSE;
if (toggle->priv->last_move == 0)
mx_toggle_set_active (toggle, !toggle->priv->active);
else
mx_toggle_set_active (toggle, (toggle->priv->last_move > 0.0));
toggle->priv->drag_offset = -1;
toggle->priv->last_move = 0;
clutter_ungrab_pointer ();
/* ensure the hover state is removed if the pointer left the handle
* during the grab */
clutter_actor_get_allocation_box (actor, &box);
if (!clutter_actor_box_contains (&box, event->x, event->y))
mx_stylable_style_pseudo_class_remove (MX_STYLABLE (actor), "hover");
return TRUE;
}
static void
mx_toggle_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *pref_height_p)
{
CoglHandle background;
gfloat pref_h;
background = mx_widget_get_background_texture (MX_WIDGET (actor));
if (!background)
{
if (min_height_p)
*min_height_p = 0;
if (pref_height_p)
*pref_height_p = 0;
return;
}
pref_h = cogl_texture_get_height (background);
if (min_height_p)
*min_height_p = pref_h;
if (pref_height_p)
*pref_height_p = pref_h;
}
static void
mex_tile_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
MxPadding padding;
gfloat box_height, label_h, icon1_h, icon2_h;
MexTilePrivate *priv = MEX_TILE (actor)->priv;
CLUTTER_ACTOR_CLASS (mex_tile_parent_class)->
get_preferred_height (actor, for_width, NULL, nat_height_p);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
for_width -= padding.left + padding.right;
/* Header */
clutter_actor_get_preferred_height (priv->box_layout, for_width, NULL, &label_h);
if (priv->icon1)
clutter_actor_get_preferred_height (priv->icon1, for_width, NULL, &icon1_h);
else
icon1_h = 0;
if (priv->icon2)
clutter_actor_get_preferred_height (priv->icon2, for_width, NULL, &icon2_h);
else
icon2_h = 0;
box_height = MAX (label_h, MAX (icon1_h, icon2_h)) +
((priv->header_padding) ? priv->header_padding->top + priv->header_padding->bottom : 0);
/* Override the minimum height with the height of the box */
if (min_height_p)
*min_height_p = box_height;
if (nat_height_p)
{
gdouble progress;
/* When the timeline is at 0.5, the actor isn't visible - this is
* the time where we switch sizes between the natural height and the
* box height.
*/
if (clutter_alpha_get_alpha (priv->important_alpha) < 0.5)
progress = 0.0;
else
progress = 1.0;
if (*nat_height_p < box_height)
*nat_height_p = box_height;
else if (progress == 0.0)
*nat_height_p = box_height;
else if (progress < 1.0)
*nat_height_p = (box_height * (1.0 - progress)) +
(*nat_height_p * progress);
}
}
static gboolean
mex_player_set_controls_visible (MexPlayer *player,
gboolean visible)
{
MexPlayerPrivate *priv = player->priv;
gfloat pos;
ClutterStage *stage;
MxFocusManager *fmanager;
stage = (ClutterStage*) clutter_actor_get_stage (CLUTTER_ACTOR (player));
fmanager = mx_focus_manager_get_for_stage (stage);
pos = clutter_actor_get_height (priv->controls);
if (visible)
{
priv->controls_prev_visible = FALSE;
priv->controls_visible = TRUE;
mx_widget_set_disabled (MX_WIDGET (priv->controls), FALSE);
clutter_actor_animate (priv->controls, CLUTTER_EASE_IN_SINE, 250,
"opacity", 0xff,
"anchor-y", 0.0,
NULL);
mex_player_restart_timer (player);
if (priv->related_tile)
{
mx_focus_manager_push_focus_with_hint (fmanager,
MX_FOCUSABLE (priv->related_tile),
MX_FOCUS_HINT_PRIOR);
g_object_unref (priv->related_tile);
priv->related_tile = NULL;
}
else
{
mx_focus_manager_push_focus (fmanager, MX_FOCUSABLE (priv->controls));
}
}
if (!visible)
{
priv->controls_visible = FALSE;
clutter_actor_animate (priv->controls, CLUTTER_EASE_IN_SINE, 250,
"opacity", 0x00,
"anchor-y", -pos,
NULL);
if (priv->hide_controls_source)
{
g_source_remove (priv->hide_controls_source);
priv->hide_controls_source = 0;
}
}
return TRUE;
}
static void
mex_column_view_get_preferred_width (ClutterActor *actor,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
MxPadding padding;
gfloat min_width, nat_width;
gfloat min_header, nat_header;
gfloat min_placeholder, nat_placeholder;
gfloat height;
MexColumnView *self = MEX_COLUMN_VIEW (actor);
MexColumnViewPrivate *priv = self->priv;
clutter_actor_get_preferred_width (priv->header,
-1,
&min_header,
&nat_header);
clutter_actor_get_preferred_height (priv->header, -1, NULL, &height);
for_height = MAX (0, for_height - height);
if (mex_column_is_empty (MEX_COLUMN (priv->column)))
{
if (priv->placeholder_actor)
{
clutter_actor_get_preferred_width (priv->placeholder_actor,
for_height,
&min_placeholder,
&nat_placeholder);
min_width = MAX (min_header, min_placeholder);
nat_width = MAX (min_header, nat_placeholder);
}
else
{
min_width = min_header;
nat_width = nat_header;
}
}
else
{
clutter_actor_get_preferred_width (priv->scroll,
for_height,
&min_placeholder,
&nat_placeholder);
min_width = MAX (min_header, min_placeholder);
nat_width = MAX (min_header, nat_placeholder);
}
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (min_width_p)
*min_width_p = min_width + padding.left + padding.right;
if (nat_width_p)
*nat_width_p = nat_width + padding.left + padding.right;
}
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
mx_toggle_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxTogglePrivate *priv = MX_TOGGLE (actor)->priv;
ClutterActorBox handle_box, child_box;
CoglHandle background;
gfloat handle_w;
gfloat toggle_pos;
CLUTTER_ACTOR_CLASS (mx_toggle_parent_class)->allocate (actor, box, flags);
mx_widget_get_available_area (MX_WIDGET (actor), box, &child_box);
/* background-image don't get stretched, so adjust the child box so that the
* handle appears in the correct place.
*/
background = mx_widget_get_background_texture (MX_WIDGET (actor));
if (background)
{
gfloat width;
MxPadding padding;
mx_widget_get_padding (MX_WIDGET (actor), &padding);
width = cogl_texture_get_width (background);
width -= padding.left + padding.right;
child_box.x1 += (child_box.x2 - child_box.x1) / 2.f;
child_box.x1 -= width / 2.f;
child_box.x2 = child_box.x1 + width;
}
clutter_actor_get_preferred_width (priv->handle, -1, NULL, &handle_w);
toggle_pos = child_box.x2 - handle_w - child_box.x1;
priv->slide_length = toggle_pos;
toggle_pos = toggle_pos * priv->position;
handle_box.x1 = (gint) (child_box.x1 + toggle_pos);
handle_box.y1 = child_box.y1;
handle_box.x2 = handle_box.x1 + handle_w;
handle_box.y2 = child_box.y2;
clutter_actor_allocate (priv->handle, &handle_box, flags);
}
static void
mx_expander_get_preferred_height (ClutterActor *actor,
gfloat for_width,
gfloat *min_height,
gfloat *pref_height)
{
MxExpanderPrivate *priv = MX_EXPANDER (actor)->priv;
ClutterActor *child;
MxPadding padding;
gfloat min_child_h, pref_child_h, min_label_h, pref_label_h, arrow_h;
gfloat available_w;
child = mx_bin_get_child (MX_BIN (actor));
mx_widget_get_padding (MX_WIDGET (actor), &padding);
available_w = for_width - padding.left - padding.right;
if (child)
{
clutter_actor_get_preferred_height (child,
available_w,
&min_child_h,
&pref_child_h);
min_child_h += priv->spacing;
pref_child_h += priv->spacing;
/* allocate the space multiplied by the progress of the "expansion"
* animation */
min_child_h *= priv->progress;
pref_child_h *= priv->progress;
}
else
{
min_child_h = 0;
pref_child_h = 0;
}
clutter_actor_get_preferred_height (priv->label,
available_w,
&min_label_h,
&pref_label_h);
clutter_actor_get_preferred_height (priv->arrow, -1, NULL, &arrow_h);
min_label_h = MAX (min_label_h, arrow_h);
pref_label_h = MAX (pref_label_h, arrow_h);
if (min_height)
*min_height = padding.top
+ min_child_h + min_label_h
+ padding.bottom;
if (pref_height)
*pref_height = padding.top
+ pref_child_h + pref_label_h
+ padding.bottom;
}
static gboolean
mx_button_enter (ClutterActor *actor,
ClutterCrossingEvent *event)
{
MxWidget *widget = MX_WIDGET (actor);
if (event->source != actor)
return FALSE;
/* check if the widget is disabled */
if (mx_widget_get_disabled (MX_WIDGET (actor)))
return FALSE;
mx_stylable_style_pseudo_class_add (MX_STYLABLE (widget), "hover");
return FALSE;
}
static void
mpl_application_view_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MplApplicationViewPrivate *priv = ((MplApplicationView *) actor)->priv;
MxPadding padding;
ClutterActorBox child_box;
gfloat icon_width = 0, icon_height = 0, button_width, button_height;
CLUTTER_ACTOR_CLASS (mpl_application_view_parent_class)->allocate (actor,
box,
flags);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* Icon */
child_box.x1 = padding.left;
child_box.y1 = padding.top;
if (priv->icon)
{
clutter_actor_get_preferred_width (priv->icon, -1, NULL, &icon_width);
clutter_actor_get_preferred_height (priv->icon, -1, NULL, &icon_height);
child_box.x2 = child_box.x1 + icon_width;
child_box.y2 = child_box.y1 + icon_height;
clutter_actor_allocate (priv->icon, &child_box, flags);
}
/* Close button */
clutter_actor_get_preferred_width (priv->close_button, -1, NULL, &button_width);
clutter_actor_get_preferred_height (priv->close_button, -1, NULL, &button_height);
child_box.x2 = box->x2 - box->x1 - padding.right;
child_box.y2 = child_box.y1 + button_height;
child_box.x1 = child_box.x2 - button_width;
clutter_actor_allocate (priv->close_button, &child_box, flags);
/* Titles */
child_box.x1 = padding.left + icon_width;
child_box.x2 = box->x2 - box->x1 - padding.right - button_width;
child_box.y2 = padding.top + icon_height;
clutter_actor_allocate (priv->title_box, &child_box, flags);
/* App frame */
child_box.x1 = padding.left;
child_box.x2 = box->x2 - box->x1 - padding.right;
child_box.y1 = padding.top + icon_width;
child_box.y2 = box->y2 - box->y1 - padding.bottom;
clutter_actor_allocate (priv->app_frame, &child_box, flags);
}
static void
mex_media_controls_notify_can_seek_cb (ClutterMedia *media,
GParamSpec *pspec,
MexMediaControls *self)
{
MexMediaControlsPrivate *priv = self->priv;
gboolean can_seek = clutter_media_get_can_seek (media);
mx_widget_set_disabled (MX_WIDGET (priv->slider), !can_seek);
}
static void
mex_tile_paint (ClutterActor *actor)
{
MexTilePrivate *priv = MEX_TILE (actor)->priv;
MxPadding padding;
ClutterActorBox box;
CLUTTER_ACTOR_CLASS (mex_tile_parent_class)->paint (actor);
clutter_actor_paint (priv->child);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
if (priv->header_visible)
{
clutter_actor_get_allocation_box (actor, &box);
if (priv->header_background_color)
{
cogl_set_source_color4ub (priv->header_background_color->red,
priv->header_background_color->green,
priv->header_background_color->blue,
priv->header_background_color->alpha);
cogl_rectangle (padding.left, padding.top,
box.x2 - box.x1 - padding.right,
priv->header_height);
}
if (cogl_material_get_n_layers (priv->material) > 0)
{
guint8 opacity;
opacity = clutter_actor_get_paint_opacity (actor);
cogl_material_set_color4ub (priv->material, opacity, opacity, opacity,
opacity);
cogl_set_source (priv->material);
cogl_rectangle (padding.left, padding.top,
box.x2 - box.x1 - padding.right,
priv->header_height);
}
clutter_actor_paint (priv->box_layout);
if (priv->icon1)
clutter_actor_paint (priv->icon1);
if (priv->icon2)
clutter_actor_paint (priv->icon2);
}
}