static void
mex_tile_style_changed_cb (MexTile *self, MxStyleChangedFlags flags)
{
MexTilePrivate *priv = self->priv;
MxBorderImage *image;
if (priv->header_padding)
{
g_boxed_free (MX_TYPE_PADDING, priv->header_padding);
priv->header_padding = NULL;
}
if (priv->header_background_color)
{
g_boxed_free (CLUTTER_TYPE_COLOR, priv->header_background_color);
priv->header_background_color = NULL;
}
mx_stylable_get (MX_STYLABLE (self),
"x-mex-header-background", &image,
"x-mex-header-background-color", &priv->header_background_color,
"x-mex-header-padding", &priv->header_padding,
NULL);
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (self),
CLUTTER_TEXT (priv->label));
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (self),
CLUTTER_TEXT (priv->secondary_label));
if (image && image->uri)
{
CoglObject *background;
background =
mx_texture_cache_get_cogl_texture (mx_texture_cache_get_default (),
image->uri);
cogl_material_set_layer (priv->material, 0, background);
}
else
{
if (cogl_material_get_n_layers (priv->material))
cogl_material_remove_layer (priv->material, 0);
}
if (image)
g_boxed_free (MX_TYPE_BORDER_IMAGE, image);
if (priv->icon1)
mx_stylable_style_changed (MX_STYLABLE (priv->icon1), flags);
if (priv->icon2)
mx_stylable_style_changed (MX_STYLABLE (priv->icon2), flags);
clutter_actor_queue_redraw (CLUTTER_ACTOR (self));
}
static void
mnb_zones_preview_style_changed_cb (MxStylable *stylable,
MxStyleChangedFlags flags,
MnbZonesPreview *self)
{
MnbZonesPreviewPrivate *priv = self->priv;
mx_stylable_get (stylable,
"spacing", &priv->spacing,
NULL);
}
static void
mnb_fancy_bin_style_changed_cb (MxStylable *stylable,
MxStyleChangedFlags flags,
MnbFancyBin *self)
{
MnbFancyBinPrivate *priv = self->priv;
mx_stylable_get (stylable,
"curve-radius", &priv->curve_radius,
NULL);
}
/**
* tb_mx_stylable_get_padding:
*
* Returns: (transfer full): the stylable padding.
*/
MxPadding *
tb_mx_stylable_get_padding (MxStylable *stylable)
{
MxPadding *padding;
mx_stylable_get (stylable,
"padding", &padding,
NULL);
return padding;
}
static void
mx_scroll_view_style_changed (MxWidget *widget, MxStyleChangedFlags flags)
{
MxScrollViewPrivate *priv = MX_SCROLL_VIEW (widget)->priv;
mx_stylable_style_changed (MX_STYLABLE (priv->hscroll), flags);
mx_stylable_style_changed (MX_STYLABLE (priv->vscroll), flags);
mx_stylable_get (MX_STYLABLE (widget),
"x-mx-scrollbar-width", &priv->scrollbar_width,
"x-mx-scrollbar-height", &priv->scrollbar_height,
NULL);
}
static void
mx_scroll_bar_style_changed (MxWidget *widget, MxStyleChangedFlags flags)
{
MxScrollBarPrivate *priv = MX_SCROLL_BAR (widget)->priv;
mx_stylable_get (MX_STYLABLE (widget),
"mx-min-size", &priv->handle_min_size,
NULL);
mx_stylable_style_changed ((MxStylable *) priv->bw_stepper, flags);
mx_stylable_style_changed ((MxStylable *) priv->fw_stepper, flags);
mx_stylable_style_changed ((MxStylable *) priv->trough, flags);
mx_stylable_style_changed ((MxStylable *) priv->handle, flags);
}
static void
mx_table_style_changed (MxWidget *widget,
gpointer userdata)
{
MxTable *table = MX_TABLE (widget);
MxTablePrivate *priv = table->priv;
guint row_spacing, col_spacing;
mx_stylable_get (MX_STYLABLE (widget),
"x-mx-column-spacing", &col_spacing,
"x-mx-row-spacing", &row_spacing,
NULL);
if (!priv->ignore_css_col_spacing)
priv->col_spacing = col_spacing;
if (!priv->ignore_css_row_spacing)
priv->row_spacing = row_spacing;
}
static void
mx_combo_box_style_changed (MxComboBox *combo, MxStyleChangedFlags flags)
{
MxBorderImage *marker_filename;
gint spacing;
MxComboBoxPrivate *priv = combo->priv;
mx_stylable_get (MX_STYLABLE (combo),
"x-mx-spacing", &spacing,
"x-mx-marker-image", &marker_filename,
NULL);
if (spacing != priv->spacing)
priv->spacing = spacing;
if (priv->marker)
{
clutter_actor_destroy (priv->marker);
priv->marker = NULL;
}
if (marker_filename)
{
MxTextureCache *cache = mx_texture_cache_get_default ();
priv->marker = (ClutterActor *)
mx_texture_cache_get_texture (cache, marker_filename->uri);
if (priv->marker)
clutter_actor_add_child (CLUTTER_ACTOR (combo), priv->marker);
g_boxed_free (MX_TYPE_BORDER_IMAGE, marker_filename);
}
mx_stylable_apply_clutter_text_attributes (MX_STYLABLE (combo),
CLUTTER_TEXT (combo->priv->label));
/* make sure the popup is also up-to-date */
mx_stylable_style_changed (MX_STYLABLE (mx_widget_get_menu (MX_WIDGET (combo))),
flags | MX_STYLE_CHANGED_FORCE);
clutter_actor_queue_relayout (CLUTTER_ACTOR (combo));
}
static void
mx_slider_style_changed_cb (MxSlider *self)
{
gboolean relayout;
gint trough_height;
guint handle_width, handle_height;
MxSliderPrivate *priv = self->priv;
mx_stylable_get (MX_STYLABLE (self),
"x-mx-trough-height", &trough_height,
"x-mx-handle-width", &handle_width,
"x-mx-handle-height", &handle_height,
NULL);
relayout = FALSE;
if (priv->trough_height != trough_height)
{
priv->trough_height = trough_height;
relayout = TRUE;
}
if (priv->handle_width != handle_width)
{
priv->handle_width = handle_width;
relayout = TRUE;
}
if (priv->handle_height != handle_height)
{
priv->handle_height = handle_height;
relayout = TRUE;
}
if (relayout)
clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
}
static void
mx_button_style_changed (MxWidget *widget)
{
MxButton *button = MX_BUTTON (widget);
MxButtonPrivate *priv = button->priv;
MxBorderImage *content_image = NULL;
/* update the label styling */
mx_button_update_label_style (button);
g_free (priv->style_icon_name);
mx_stylable_get (MX_STYLABLE (widget),
"x-mx-content-image", &content_image,
"x-mx-icon-name", &priv->style_icon_name,
"x-mx-icon-size", &priv->style_icon_size,
NULL);
if (content_image && content_image->uri)
{
if (priv->content_image)
{
clutter_actor_remove_child (CLUTTER_ACTOR (widget),
priv->content_image);
}
priv->content_image =
(ClutterActor*) mx_texture_cache_get_texture (mx_texture_cache_get_default (),
content_image->uri);
if (priv->content_image)
clutter_actor_add_child (CLUTTER_ACTOR (widget), priv->content_image);
else
g_warning ("Could not load content image \"%s\"", content_image->uri);
g_boxed_free (MX_TYPE_BORDER_IMAGE, content_image);
return;
}
else
{
/* remove any previous content image */
if (priv->content_image)
{
clutter_actor_remove_child (CLUTTER_ACTOR (widget),
priv->content_image);
priv->content_image = NULL;
}
if (content_image)
g_boxed_free (MX_TYPE_BORDER_IMAGE, content_image);
}
if (priv->icon_size == 0)
mx_icon_set_icon_size (MX_ICON (priv->icon), priv->style_icon_size);
if (priv->style_icon_name && !priv->icon_name)
{
mx_icon_set_icon_name (MX_ICON (priv->icon), priv->style_icon_name);
mx_button_update_contents (button);
}
}
static void
mx_scroll_view_paint (ClutterActor *actor)
{
ClutterActorBox box;
gfloat w, h;
MxAdjustment *vadjustment = NULL, *hadjustment = NULL;
MxScrollViewPrivate *priv = MX_SCROLL_VIEW (actor)->priv;
ClutterColor *color;
guint8 r, g, b;
const gint shadow = 15;
mx_stylable_get (MX_STYLABLE (actor), "background-color", &color, NULL);
r = color->red;
g = color->green;
b = color->blue;
clutter_color_free (color);
/* MxBin will paint the child */
CLUTTER_ACTOR_CLASS (mx_scroll_view_parent_class)->paint (actor);
clutter_actor_get_allocation_box (actor, &box);
w = box.x2 - box.x1;
h = box.y2 - box.y1;
/* paint our custom children */
if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
{
clutter_actor_paint (priv->hscroll);
clutter_actor_get_allocation_box (priv->hscroll, &box);
h -= (box.y2 - box.y1);
hadjustment = mx_scroll_bar_get_adjustment (MX_SCROLL_BAR(priv->hscroll));
}
if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
{
clutter_actor_paint (priv->vscroll);
clutter_actor_get_allocation_box (priv->vscroll, &box);
w -= (box.x2 - box.x1);
vadjustment = mx_scroll_bar_get_adjustment (MX_SCROLL_BAR(priv->vscroll));
}
/* set up the matrial using dummy set source call */
cogl_set_source_color4ub (0, 0, 0, 0);
if (vadjustment)
{
gdouble len;
if ((len = mx_adjustment_get_value (vadjustment)) > 0)
{
CoglTextureVertex top[4] = { { 0,}, };
if (len > shadow)
len = shadow;
top[1].x = w;
top[2].x = w;
top[2].y = len;
top[3].y = len;
cogl_color_set_from_4ub (&top[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&top[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&top[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&top[3].color, 0, 0, 0, 0);
cogl_polygon (top, 4, TRUE);
}
if ((len = (mx_adjustment_get_upper (vadjustment)
- mx_adjustment_get_page_size (vadjustment))
- mx_adjustment_get_value (vadjustment)) > 0)
{
CoglTextureVertex bottom[4] = { {0, }, };
if (len > shadow)
len = shadow;
bottom[0].x = w;
bottom[0].y = h;
bottom[1].y = h;
bottom[2].y = h - len;
bottom[3].x = w;
bottom[3].y = h - len;
cogl_color_set_from_4ub (&bottom[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&bottom[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&bottom[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&bottom[3].color, 0, 0, 0, 0);
cogl_polygon (bottom, 4, TRUE);
}
}
if (hadjustment)
{
gdouble len;
if ((len = mx_adjustment_get_value (hadjustment)) > 0)
{
CoglTextureVertex left[4] = { { 0, }, };
if (len > shadow)
len = shadow;
left[0].y = h;
left[2].x = len;
left[3].x = len;
left[3].y = h;
cogl_color_set_from_4ub (&left[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&left[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&left[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&left[3].color, 0, 0, 0, 0);
cogl_polygon (left, 4, TRUE);
}
if ((len = (mx_adjustment_get_upper (hadjustment)
- mx_adjustment_get_page_size (hadjustment))
- mx_adjustment_get_value (hadjustment)) > 0)
{
CoglTextureVertex right[4] = { { 0, }, };
if (len > shadow)
len = shadow;
right[0].x = w;
right[1].x = w;
right[1].y = h;
right[2].x = w - len;
right[2].y = h;
right[3].x = w - len;
cogl_color_set_from_4ub (&right[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&right[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&right[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&right[3].color, 0, 0, 0, 0);
cogl_polygon (right, 4, TRUE);
}
}
}
static void
mx_scroll_bar_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
MxScrollBarPrivate *priv = MX_SCROLL_BAR (actor)->priv;
MxPadding padding;
ClutterActorBox bw_box, fw_box, trough_box;
gfloat x, y, width, height, stepper_size;
/* Chain up */
CLUTTER_ACTOR_CLASS (mx_scroll_bar_parent_class)->allocate (actor, box,
flags);
mx_widget_get_padding (MX_WIDGET (actor), &padding);
/* calculate the child area */
x = padding.left;
y = padding.top;
width = (box->x2 - box->x1) - padding.left - padding.right;
height = (box->y2 - box->y1) - padding.top - padding.bottom;
if (priv->orientation == MX_ORIENTATION_VERTICAL)
{
stepper_size = width;
/* Backward stepper */
bw_box.x1 = x;
bw_box.y1 = y;
bw_box.x2 = bw_box.x1 + stepper_size;
bw_box.y2 = bw_box.y1 + stepper_size;
clutter_actor_allocate (priv->bw_stepper, &bw_box, flags);
/* Forward stepper */
fw_box.x1 = x;
fw_box.y1 = y + height - stepper_size;
fw_box.x2 = fw_box.x1 + stepper_size;
fw_box.y2 = fw_box.y1 + stepper_size;
clutter_actor_allocate (priv->fw_stepper, &fw_box, flags);
/* Trough */
trough_box.x1 = x;
trough_box.y1 = y + stepper_size;
trough_box.x2 = x + width;
trough_box.y2 = y + height - stepper_size;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
else
{
stepper_size = height;
/* Backward stepper */
bw_box.x1 = x;
bw_box.y1 = y;
bw_box.x2 = bw_box.x1 + stepper_size;
bw_box.y2 = bw_box.y1 + stepper_size;
clutter_actor_allocate (priv->bw_stepper, &bw_box, flags);
/* Forward stepper */
fw_box.x1 = x + width - stepper_size;
fw_box.y1 = y;
fw_box.x2 = fw_box.x1 + stepper_size;
fw_box.y2 = fw_box.y1 + stepper_size;
clutter_actor_allocate (priv->fw_stepper, &fw_box, flags);
/* Trough */
trough_box.x1 = x + stepper_size;
trough_box.y1 = y;
trough_box.x2 = x + width - stepper_size;
trough_box.y2 = y + height;
clutter_actor_allocate (priv->trough, &trough_box, flags);
}
if (priv->adjustment)
{
gfloat handle_size, position, avail_size, handle_pos;
gdouble value, lower, upper, page_size, increment;
ClutterActorBox handle_box = { 0, };
guint min_size, max_size;
mx_adjustment_get_values (priv->adjustment,
&value,
&lower,
&upper,
NULL,
NULL,
&page_size);
value = mx_adjustment_get_value (priv->adjustment);
if ((upper == lower)
|| (page_size >= (upper - lower)))
increment = 1.0;
else
increment = page_size / (upper - lower);
min_size = priv->handle_min_size;
mx_stylable_get (MX_STYLABLE (actor),
"mx-max-size", &max_size,
NULL);
if (upper - lower - page_size <= 0)
position = 0;
else
position = (value - lower) / (upper - lower - page_size);
if (priv->orientation == MX_ORIENTATION_VERTICAL)
{
avail_size = height - stepper_size * 2;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_box.x1 = x;
handle_pos = bw_box.y2 + position * (avail_size - handle_size);
handle_box.y1 = CLAMP (handle_pos,
bw_box.y2, fw_box.y1 - min_size);
handle_box.x2 = handle_box.x1 + width;
handle_box.y2 = CLAMP (handle_pos + handle_size,
bw_box.y2 + min_size, fw_box.y1);
}
else
{
avail_size = width - stepper_size * 2;
handle_size = increment * avail_size;
handle_size = CLAMP (handle_size, min_size, max_size);
handle_pos = bw_box.x2 + position * (avail_size - handle_size);
handle_box.x1 = CLAMP (handle_pos,
bw_box.x2, fw_box.x1 - min_size);
handle_box.y1 = y;
handle_box.x2 = CLAMP (handle_pos + handle_size,
bw_box.x2 + min_size, fw_box.x1);
handle_box.y2 = handle_box.y1 + height;
}
/* snap to pixel */
handle_box.x1 = (int) handle_box.x1;
handle_box.y1 = (int) handle_box.y1;
handle_box.x2 = (int) handle_box.x2;
handle_box.y2 = (int) handle_box.y2;
clutter_actor_allocate (priv->handle,
&handle_box,
flags);
}
}
static void
mx_tooltip_style_changed (MxWidget *self)
{
ClutterColor *color = NULL;
MxTooltipPrivate *priv;
gchar *font_name;
gchar *font_string;
gint font_size;
MxBorderImage *border_image;
priv = MX_TOOLTIP (self)->priv;
mx_stylable_get (MX_STYLABLE (self),
"color", &color,
"font-family", &font_name,
"font-size", &font_size,
"border-image", &border_image,
NULL);
if (color)
{
clutter_text_set_color (CLUTTER_TEXT (priv->label), color);
clutter_color_free (color);
}
if (font_name || font_size)
{
if (font_name && font_size)
{
font_string = g_strdup_printf ("%s %dpx", font_name, font_size);
g_free (font_name);
}
else
if (font_size)
font_string = g_strdup_printf ("%dpx", font_size);
else
font_string = font_name;
clutter_text_set_font_name (CLUTTER_TEXT (priv->label), font_string);
g_free (font_string);
}
/* remove existing border image */
if (priv->border_image)
{
g_boxed_free (MX_TYPE_BORDER_IMAGE, priv->border_image);
priv->border_image = NULL;
}
if (priv->border_image_texture)
{
cogl_handle_unref (priv->border_image_texture);
priv->border_image_texture = NULL;
}
if (border_image)
{
priv->border_image_texture =
mx_texture_cache_get_cogl_texture (mx_texture_cache_get_default (),
border_image->uri);
priv->border_image = border_image;
}
clutter_actor_queue_relayout (CLUTTER_ACTOR (self));
}
