static void
penge_grid_view_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
PengeGridViewPrivate *priv = GET_PRIVATE (actor);
ClutterActorBox child_box;
gint fade_height;
/* Allocate the background to be the same area as the grid view */
child_box.x1 = 0;
child_box.y1 = 0;
child_box.x2 = box->x2 - box->x1;
child_box.y2 = box->y2 - box->y1;
clutter_actor_allocate (priv->background, &child_box, flags);
clutter_texture_get_base_size (CLUTTER_TEXTURE (priv->background_fade),
NULL,
&fade_height);
child_box.x1 = 0;
child_box.y1 = 0;
child_box.x2 = box->x2 - box->x1;
child_box.y2 = fade_height;
clutter_actor_allocate (priv->background_fade, &child_box, flags);
CLUTTER_ACTOR_CLASS (penge_grid_view_parent_class)->allocate (actor,
box,
flags);
}
static void
st_icon_update_shadow_material (StIcon *icon)
{
StIconPrivate *priv = icon->priv;
if (priv->shadow_material)
{
cogl_handle_unref (priv->shadow_material);
priv->shadow_material = COGL_INVALID_HANDLE;
}
if (priv->shadow_spec)
{
CoglHandle material;
gint width, height;
clutter_texture_get_base_size (CLUTTER_TEXTURE (priv->icon_texture),
&width, &height);
material = _st_create_shadow_material_from_actor (priv->shadow_spec,
priv->icon_texture);
priv->shadow_material = material;
priv->shadow_width = width;
priv->shadow_height = height;
}
}
static void rc_update_pixbuf(void *renderer, gboolean lazy)
{
RendererClutter *rc = (RendererClutter *)renderer;
PixbufRenderer *pr = rc->pr;
DEBUG_3("rc_update_pixbuf");
rc_remove_pending_updates(rc);
rc->last_pixbuf_change = g_get_monotonic_time();
DEBUG_3("%s change time reset", get_exec_time());
if (pr->pixbuf)
{
gint width = gdk_pixbuf_get_width(pr->pixbuf);
gint height = gdk_pixbuf_get_height(pr->pixbuf);
DEBUG_3("pixbuf size %d x %d (%d)", width, height, gdk_pixbuf_get_has_alpha(pr->pixbuf) ? 32 : 24);
gint prev_width, prev_height;
if (pr->stereo_data == STEREO_PIXBUF_SBS || pr->stereo_data == STEREO_PIXBUF_CROSS)
{
width /= 2;
}
clutter_texture_get_base_size(CLUTTER_TEXTURE(rc->texture), &prev_width, &prev_height);
if (width != prev_width || height != prev_height)
{
/* FIXME use CoglMaterial with multiple textures for background, color management, anaglyph, ... */
CoglHandle texture = cogl_texture_new_with_size(width,
height,
COGL_TEXTURE_NO_AUTO_MIPMAP | COGL_TEXTURE_NO_SLICING,
gdk_pixbuf_get_has_alpha(pr->pixbuf) ? COGL_PIXEL_FORMAT_BGRA_8888 : COGL_PIXEL_FORMAT_BGR_888);
if (texture != COGL_INVALID_HANDLE)
{
clutter_texture_set_cogl_texture(CLUTTER_TEXTURE(rc->texture), texture);
cogl_handle_unref(texture);
}
}
clutter_actor_set_clip(rc->texture, 0, 0, 0, 0); /* visible area is extended as area_changed events arrive */
if (!lazy)
{
rc_area_changed(renderer, GET_RIGHT_PIXBUF_OFFSET(rc), 0, width, height);
}
}
rc->clut_updated = FALSE;
}
static void
mnb_spinner_paint (ClutterActor *self)
{
MnbSpinnerPrivate *priv = MNB_SPINNER (self)->priv;
MxWidget *widget = MX_WIDGET (self);
ClutterTexture *background;
/*
* This paints border-image.
*/
CLUTTER_ACTOR_CLASS (mnb_spinner_parent_class)->paint (self);
if ((background = (ClutterTexture *) mx_widget_get_background_image (widget)))
{
gint tx_w, tx_h;
gfloat tf_x, tf_y, tf_w, tf_h;
guint8 opacity;
ClutterActorBox box = { 0, };
CoglHandle material;
if (!CLUTTER_IS_TEXTURE (background))
return;
opacity = clutter_actor_get_paint_opacity (self);
if (opacity == 0)
return;
clutter_texture_get_base_size (background, &tx_w, &tx_h);
material = clutter_texture_get_cogl_material (background);
cogl_material_set_color4ub (material, opacity, opacity, opacity, opacity);
clutter_actor_get_allocation_box (self, &box);
tf_x = (gfloat)priv->frame / (gfloat) priv->n_frames;
tf_y = 0.0;
tf_w = tf_x + 1.0 / priv->n_frames;
tf_h = 1.0;
/* Paint will have translated us */
cogl_set_source (material);
cogl_rectangle_with_texture_coords (0.0, 0.0,
box.x2 - box.x1,
box.y2 - box.y1,
tf_x, tf_y, tf_w, tf_h);
}
}
static void
st_icon_update_shadow_pipeline (StIcon *icon)
{
StIconPrivate *priv = icon->priv;
g_clear_pointer (&priv->shadow_pipeline, cogl_object_unref);
if (priv->shadow_spec)
{
gint width, height;
clutter_texture_get_base_size (CLUTTER_TEXTURE (priv->icon_texture),
&width, &height);
priv->shadow_pipeline = _st_create_shadow_pipeline_from_actor (priv->shadow_spec, priv->icon_texture);
priv->shadow_width = width;
priv->shadow_height = height;
}
}
static void
mnb_spinner_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
MxWidget *widget = MX_WIDGET (self);
ClutterTexture *background;
if ((background = (ClutterTexture *) mx_widget_get_background_image (widget)))
{
gint tx_w, tx_h;
if (!CLUTTER_IS_TEXTURE (background))
return;
/*
* The background texture is a strip of squares making up the individual
* frames in the animation, so the width matches the height of the
* texture.
*/
clutter_texture_get_base_size (background, &tx_w, &tx_h);
if (min_height_p)
*min_height_p = tx_h;
if (natural_height_p)
*natural_height_p = tx_h;
return;
}
if (min_height_p)
*min_height_p = 0.0;
if (natural_height_p)
*natural_height_p = 0.0;
}
static void
opt_show_update_position_label (OptShow *show)
{
OptShowPrivate *priv = show->priv;
ClutterActor *stage;
ClutterGeometry stage_geom;
ClutterGeometry rect_geom;
gint label_width, label_height;
gchar *pos;
if (!priv->position_label)
return;
stage = clutter_stage_get_default ();
clutter_actor_get_geometry (stage, &stage_geom);
pos = g_strdup_printf ("%d/%d",
priv->current_slide_num + 1,
priv->num_slides);
clutter_text_set_text (CLUTTER_TEXT (priv->position_label), pos);
clutter_texture_get_base_size (CLUTTER_TEXTURE (priv->position_label),
&label_width,
&label_height);
rect_geom.width = label_width + 50;
rect_geom.height = label_height + 20;
rect_geom.x = (stage_geom.width / 2) - (rect_geom.width / 2);
rect_geom.y = stage_geom.height - rect_geom.height - 10;
clutter_actor_set_geometry (priv->position_rect, &rect_geom);
clutter_actor_set_position (priv->position_label,
rect_geom.x + 25,
rect_geom.y + 10);
g_free (pos);
}
static void
set_clear_button_size (ClutterActor *clear_button)
{
/* TODO quick fix for MX port. */
clutter_actor_set_size (clear_button, 22, 21);
#if 0
GValue background_image = { 0, };
g_value_init (&background_image, G_TYPE_STRING);
mx_stylable_get_property (MX_STYLABLE (clear_button),
"background-image", &background_image);
if (g_value_get_string (&background_image))
{
GError *error = NULL;
ClutterActor *background_texture = clutter_texture_new_from_file (
g_value_get_string (&background_image),
&error);
if (error)
{
g_warning ("%s", error->message);
g_error_free (error);
}
else
{
gint width, height;
clutter_texture_get_base_size (CLUTTER_TEXTURE (background_texture),
&width, &height);
clutter_actor_set_size (clear_button, width, height);
g_object_unref (background_texture);
}
g_value_unset (&background_image);
}
#endif
}
static void
mnb_spinner_constructed (GObject *self)
{
MnbSpinnerPrivate *priv = MNB_SPINNER (self)->priv;
MxWidget *widget = MX_WIDGET (self);
ClutterTexture *background;
ClutterTimeline *timeline;
/*
* Mx does not seem to load the style info until the first show, but we want
* to get hold of the background asset here to work out the frame count, so
* we need to force the style loading.
*
* NB: mx_widget_ensure_style() does not work here, because the MxWidget
* is_style_dirty flag is cleared at this point.
*/
mx_stylable_style_changed (MX_STYLABLE (widget), MX_STYLE_CHANGED_FORCE);
if ((background = (ClutterTexture *) mx_widget_get_background_image (widget)))
{
gint tx_w, tx_h;
guint duration;
if (!CLUTTER_IS_TEXTURE (background))
{
g_critical ("Expected ClutterTexture, but got %s",
G_OBJECT_TYPE_NAME (background));
return;
}
/*
* The background texture is a strip of squares making up the individual
* frames in the animation, so the width matches the height of the
* texture.
*/
clutter_texture_get_base_size (background, &tx_w, &tx_h);
priv->n_frames = tx_w / tx_h;
if (tx_w % tx_h)
g_warning (G_STRLOC ": Expected texture size %d x %d, got %d x %d",
tx_h * priv->n_frames, tx_h, tx_w, tx_h);
/*
* Setup a looped timeline with a marker that fires everytime we should
* advance to a new frame.
*
* Assume the whole animation is to last 1s.
*/
duration = 1000/ priv->n_frames;
timeline = priv->timeline = clutter_timeline_new (duration);
clutter_timeline_set_loop (timeline, TRUE);
clutter_timeline_add_marker_at_time (timeline, "next", duration);
clutter_timeline_stop (timeline);
g_signal_connect (timeline, "marker-reached",
G_CALLBACK (mnb_spinner_marker_reached_cb),
self);
}
else
g_warning ("%s did not have background-image set in style !!!",
G_OBJECT_TYPE_NAME (self));
}
static void
tidy_texture_frame_paint (ClutterActor *self)
{
TidyTextureFramePrivate *priv;
ClutterActor *parent_texture;
guint width, height;
gint pwidth, pheight, ex, ey;
ClutterFixed tx1, ty1, tx2, ty2, tw, th;
GLenum target_type;
ClutterColor col = { 0xff, 0xff, 0xff, 0xff };
priv = TIDY_TEXTURE_FRAME (self)->priv;
/* no need to paint stuff if we don't have a texture to reflect */
if (!clutter_clone_texture_get_parent_texture (CLUTTER_CLONE_TEXTURE(self)))
return;
/* parent texture may have been hidden, there for need to make sure its
* realised with resources available.
*/
parent_texture
= CLUTTER_ACTOR
(clutter_clone_texture_get_parent_texture(CLUTTER_CLONE_TEXTURE(self)));
if (!CLUTTER_ACTOR_IS_REALIZED (parent_texture))
clutter_actor_realize (parent_texture);
if (clutter_texture_is_tiled (CLUTTER_TEXTURE (parent_texture)))
{
g_warning("tiled textures not yet supported...");
return;
}
cogl_push_matrix ();
#define FX(x) CLUTTER_INT_TO_FIXED(x)
clutter_texture_get_base_size (CLUTTER_TEXTURE(parent_texture),
&pwidth, &pheight);
clutter_actor_get_size (self, &width, &height);
tx1 = FX (priv->left);
tx2 = FX (pwidth - priv->right);
ty1 = FX (priv->top);
ty2 = FX (pheight - priv->bottom);
tw = FX (pwidth);
th = FX (pheight);
if (clutter_feature_available (CLUTTER_FEATURE_TEXTURE_RECTANGLE))
{
target_type = CGL_TEXTURE_RECTANGLE_ARB;
cogl_enable (CGL_ENABLE_TEXTURE_RECT|CGL_ENABLE_BLEND);
}
else
{
target_type = CGL_TEXTURE_2D;
cogl_enable (CGL_ENABLE_TEXTURE_2D|CGL_ENABLE_BLEND);
tw = clutter_util_next_p2 (pwidth);
th = clutter_util_next_p2 (pheight);
tx1 = tx1/tw;
tx2 = tx2/tw;
ty1 = ty1/th;
ty2 = ty2/th;
tw = FX(pwidth)/tw;
th = FX(pheight)/th;
}
col.alpha = clutter_actor_get_opacity (self);
cogl_color (&col);
clutter_texture_bind_tile (CLUTTER_TEXTURE(parent_texture), 0);
ex = width - priv->right;
if (ex < 0)
ex = priv->right; /* FIXME */
ey = height - priv->bottom;
if (ey < 0)
ey = priv->bottom; /* FIXME */
/* top left corner */
cogl_texture_quad (0,
priv->left, /* FIXME: clip if smaller */
0,
priv->top,
0,
0,
tx1,
ty1);
/* top middle */
cogl_texture_quad (priv->left,
ex,
0,
priv->top,
tx1,
0,
tx2,
ty1);
/* top right */
cogl_texture_quad (ex,
width,
0,
priv->top,
tx2,
0,
tw,
ty1);
/* mid left */
cogl_texture_quad (0,
priv->left,
priv->top,
ey,
0,
ty1,
tx1,
ty2);
/* center */
cogl_texture_quad (priv->left,
ex,
priv->top,
ey,
tx1,
ty1,
tx2,
ty2);
/* mid right */
cogl_texture_quad (ex,
width,
priv->top,
ey,
tx2,
ty1,
tw,
ty2);
/* bottom left */
cogl_texture_quad (0,
priv->left,
ey,
height,
0,
ty2,
tx1,
th);
/* bottom center */
cogl_texture_quad (priv->left,
ex,
ey,
height,
tx1,
ty2,
tx2,
th);
/* bottom right */
cogl_texture_quad (ex,
width,
ey,
height,
tx2,
ty2,
tw,
th);
cogl_pop_matrix ();
#undef FX
}
static void
reflect_texture_render_to_gl_quad (ClutterReflectTexture *ctexture,
int x1,
int y1,
int x2,
int y2)
{
gint qx1 = 0, qx2 = 0, qy1 = 0, qy2 = 0;
gint qwidth = 0, qheight = 0;
gint x, y, i =0, lastx = 0, lasty = 0;
gint n_x_tiles, n_y_tiles;
gint pwidth, pheight, rheight;
float tx, ty, ty2 = 0.0;
ClutterReflectTexturePrivate *priv = ctexture->priv;
ClutterActor *parent_texture = CLUTTER_ACTOR(clutter_clone_texture_get_parent_texture(CLUTTER_CLONE_TEXTURE(ctexture)));
priv = ctexture->priv;
qwidth = x2 - x1;
qheight = y2 - y1;
rheight = priv->reflection_height;
if (rheight > qheight)
rheight = qheight;
if (!CLUTTER_ACTOR_IS_REALIZED (parent_texture))
clutter_actor_realize (parent_texture);
/* Only paint if parent is in a state to do so */
if (!clutter_texture_has_generated_tiles (CLUTTER_TEXTURE(parent_texture)))
return;
clutter_texture_get_base_size (CLUTTER_TEXTURE(parent_texture),
&pwidth, &pheight);
if (!clutter_texture_is_tiled (CLUTTER_TEXTURE(parent_texture)))
{
clutter_texture_bind_tile (CLUTTER_TEXTURE(parent_texture), 0);
/* NPOTS textures *always* used if extension available
*/
if (clutter_feature_available (CLUTTER_FEATURE_TEXTURE_RECTANGLE))
{
tx = (float) pwidth;
ty = (float) pheight;
ty2 = (float)(clutter_actor_get_height (CLUTTER_ACTOR(ctexture)) * rheight)
/ pheight;
ty2 = pheight - ty2;
}
else
{
tx = (float) pwidth / clutter_util_next_p2 (pwidth);
ty = (float) pheight / clutter_util_next_p2 (pheight);
}
qx1 = x1; qx2 = x2;
qy1 = y1; qy2 = y1 + rheight;
glBegin (GL_QUADS);
glColor4ub (255, 255, 255,
clutter_actor_get_opacity (CLUTTER_ACTOR(ctexture)));
glTexCoord2f (0, ty);
glVertex2i (qx1, qy1);
glTexCoord2f (tx, ty);
glVertex2i (qx2, qy1);
glColor4ub (255, 255, 255, 0);
glTexCoord2f (tx, ty2);
glVertex2i (qx2, qy2);
glTexCoord2f (0, ty2);
glVertex2i (qx1, qy2);
glEnd ();
return;
}
clutter_texture_get_n_tiles (CLUTTER_TEXTURE(parent_texture),
&n_x_tiles, &n_y_tiles);
for (x = 0; x < n_x_tiles; x++)
{
lasty = 0;
for (y = 0; y < n_y_tiles; y++)
{
gint actual_w, actual_h;
gint xpos, ypos, xsize, ysize, ywaste, xwaste;
clutter_texture_bind_tile (CLUTTER_TEXTURE(parent_texture), i);
clutter_texture_get_x_tile_detail (CLUTTER_TEXTURE(parent_texture),
x, &xpos, &xsize, &xwaste);
clutter_texture_get_y_tile_detail (CLUTTER_TEXTURE(parent_texture),
y, &ypos, &ysize, &ywaste);
actual_w = xsize - xwaste;
actual_h = ysize - ywaste;
tx = (float) actual_w / xsize;
ty = (float) actual_h / ysize;
qx1 = x1 + lastx;
qx2 = qx1 + ((qwidth * actual_w ) / pwidth );
qy1 = y1 + lasty;
qy2 = qy1 + ((qheight * actual_h) / pheight );
glBegin (GL_QUADS);
glTexCoord2f (tx, ty); glVertex2i (qx2, qy2);
glTexCoord2f (0, ty); glVertex2i (qx1, qy2);
glTexCoord2f (0, 0); glVertex2i (qx1, qy1);
glTexCoord2f (tx, 0); glVertex2i (qx2, qy1);
glEnd ();
lasty += qy2 - qy1;
i++;
}
lastx += qx2 - qx1;
}
}
void
scroll_view_main (ClutterContainer *stage)
{
gint width, height;
MxAdjustment *hadjust, *vadjust;
ClutterActor *label, *elastic, *overshoot, *scroll, *kinetic, *view, *texture;
scroll = mx_scroll_view_new ();
/* Make sure something underneath the kinetic scroll view swallows events
* so that we don't end up moving the window.
*/
g_signal_connect (scroll, "button-press-event", G_CALLBACK (true_cb), NULL);
kinetic = mx_kinetic_scroll_view_new ();
clutter_container_add_actor (stage, scroll);
clutter_actor_set_position (scroll, 10, 10);
clutter_actor_set_size (scroll, 300, 300);
view = mx_viewport_new ();
mx_viewport_set_sync_adjustments (MX_VIEWPORT (view), FALSE);
clutter_container_add_actor (CLUTTER_CONTAINER (kinetic), view);
clutter_container_add_actor (CLUTTER_CONTAINER (scroll), kinetic);
texture = clutter_texture_new_from_file ("redhand.png", NULL);
clutter_container_add_actor (CLUTTER_CONTAINER (view), texture);
g_object_set (texture, "repeat-x", TRUE, "repeat-y", TRUE, NULL);
clutter_actor_set_size (texture, 1280, 1280);
clutter_texture_get_base_size (CLUTTER_TEXTURE (texture),
&width, &height);
mx_scrollable_get_adjustments (MX_SCROLLABLE (view),
&hadjust, &vadjust);
mx_adjustment_set_values (hadjust,
0,
0,
1280,
width,
width * 3,
300);
mx_adjustment_set_values (vadjust,
0,
0,
1280,
height,
height * 3,
300);
label = mx_label_new_with_text ("Toggle over-shooting:");
overshoot = mx_toggle_new ();
clutter_actor_set_position (label, 320, 10);
clutter_actor_set_position (overshoot, 330 + clutter_actor_get_width (label),
10);
clutter_container_add (stage, label, overshoot, NULL);
g_signal_connect (overshoot, "notify::active",
G_CALLBACK (notify_overshoot_cb), kinetic);
label = mx_label_new_with_text ("Toggle elasticity:");
elastic = mx_toggle_new ();
clutter_actor_set_position (label, 320,
20 + clutter_actor_get_height (overshoot));
clutter_actor_set_position (elastic, clutter_actor_get_x (overshoot),
clutter_actor_get_y (label));
clutter_container_add (stage, label, elastic, NULL);
g_signal_connect (elastic, "notify::active",
G_CALLBACK (notify_elastic_cb), kinetic);
}
static void
add_pictures (ClutterActor *box)
{
GList *files = get_pictures ();
while (files)
{
gint w, h, i;
ClutterActor *drawer, *drawer2, *tile, *texture, *menu, *description;
gchar *file = files->data;
/* Create texture */
texture = clutter_texture_new_from_file (file, NULL);
clutter_texture_get_base_size (CLUTTER_TEXTURE (texture), &w, &h);
clutter_actor_set_size (texture, 300, 300.0/w * h);
/* Create menu */
menu = mx_box_layout_new ();
mx_box_layout_set_orientation (MX_BOX_LAYOUT (menu),
MX_ORIENTATION_VERTICAL);
for (i = 0; i < 4; i++)
{
ClutterActor *button, *layout, *icon, *label;
button = mx_button_new ();
layout = mx_box_layout_new ();
icon = mx_icon_new ();
label = mx_label_new ();
mx_box_layout_set_spacing (MX_BOX_LAYOUT (layout), 8);
mx_icon_set_icon_size (MX_ICON (icon), 16);
clutter_actor_set_size (icon, 16, 16);
clutter_container_add (CLUTTER_CONTAINER (layout),
icon, label, NULL);
mx_bin_set_child (MX_BIN (button), layout);
mx_bin_set_alignment (MX_BIN (button),
MX_ALIGN_START,
MX_ALIGN_MIDDLE);
clutter_container_add_actor (CLUTTER_CONTAINER (menu), button);
mx_box_layout_child_set_x_fill (MX_BOX_LAYOUT (menu), button, TRUE);
switch (i)
{
case 0:
mx_icon_set_icon_name (MX_ICON (icon), "dialog-information");
mx_label_set_text (MX_LABEL (label), "This");
break;
case 1:
mx_icon_set_icon_name (MX_ICON (icon), "dialog-question");
mx_label_set_text (MX_LABEL (label), "is");
break;
case 2:
mx_icon_set_icon_name (MX_ICON (icon), "dialog-warning");
mx_label_set_text (MX_LABEL (label), "a");
break;
case 3:
mx_icon_set_icon_name (MX_ICON (icon), "dialog-error");
mx_label_set_text (MX_LABEL (label), "menu");
break;
}
}
/* Create description */
description = mx_label_new_with_text ("Here you could put a very "
"long description of whatever "
"is above it. Or you could put "
"another focusable widget here "
"and it'd be navigable, like "
"the menu on the right. Whoo!");
clutter_text_set_line_wrap ((ClutterText *)mx_label_get_clutter_text (
MX_LABEL (description)), TRUE);
drawer = mex_expander_box_new ();
mex_expander_box_set_important_on_focus (MEX_EXPANDER_BOX (drawer), TRUE);
drawer2 = mex_expander_box_new ();
mex_expander_box_set_grow_direction (MEX_EXPANDER_BOX (drawer2),
MEX_EXPANDER_BOX_RIGHT);
mex_expander_box_set_important (MEX_EXPANDER_BOX (drawer2), TRUE);
tile = mex_tile_new_with_label (file);
mex_tile_set_important (MEX_TILE (tile), TRUE);
mx_bin_set_child (MX_BIN (tile), texture);
clutter_container_add (CLUTTER_CONTAINER (drawer2), tile, menu, NULL);
clutter_container_add (CLUTTER_CONTAINER (drawer),
drawer2, description, NULL);
g_signal_connect (drawer, "notify::open",
G_CALLBACK (sync_drawer2_cb), drawer2);
clutter_container_add_actor (CLUTTER_CONTAINER (box), drawer);
clutter_actor_set_reactive (texture, TRUE);
g_signal_connect (texture, "enter-event",
G_CALLBACK (texture_enter_cb), drawer);
g_signal_connect (texture, "leave-event",
G_CALLBACK (texture_leave_cb), drawer);
g_signal_connect (texture, "button-press-event",
G_CALLBACK (texture_clicked_cb), drawer);
g_free (file);
files = g_list_delete_link (files, files);
}
}
static void on_gesture_end(ClutterGestureAction *action, ClutterActor *stage, gpointer data) {
ClutterActor *new_actor, *texture, *actor;
gfloat x, y, w, h;
GError *error = NULL;
GdkColor color;
guint16 alpha;
gint iw = 125;
gint ih = 126;
gboolean repeat_x = FALSE;
gboolean repeat_y = TRUE;
guint bgr;
new_actor = tmpRect;
gtk_color_button_get_color(GTK_COLOR_BUTTON(app.colorpicker), &color);
alpha = gtk_color_button_get_alpha(GTK_COLOR_BUTTON(app.colorpicker));
ClutterColor col = {
CLAMP(((color.red / 65535.0) * 255), 0, 255),
CLAMP(((color.green / 65535.0) * 255), 0, 255),
CLAMP(((color.blue / 65535.0) * 255), 0, 255),
CLAMP(((alpha / 65535.0) * 255), 0, 255),
};
clutter_rectangle_set_color(CLUTTER_RECTANGLE(new_actor), &col);
clutter_rectangle_set_border_width(CLUTTER_RECTANGLE(new_actor), 0);
tmpRect = NULL;
clutter_actor_get_position(new_actor, &x, &y);
clutter_actor_get_size(new_actor, &w, &h);
if (background_image_file != NULL){
texture = clutter_texture_new_from_file(background_image_file, &error);
if (error != NULL){
g_print("Loading image failed\n");
g_error_free(error);
}
clutter_actor_set_position(texture, x, y);
clutter_actor_set_size(texture, w, h);
clutter_actor_add_child(stage, texture);
clutter_actor_show(texture);
bgr = gtk_combo_box_get_active(GTK_COMBO_BOX(app.background_repeat_select));
switch (bgr){
case 0:
repeat_x = repeat_y = FALSE;
break;
case 1:
repeat_x = TRUE; repeat_y = FALSE;
break;
case 2:
repeat_x = FALSE; repeat_y = TRUE;
break;
case 3:
repeat_x = repeat_y = TRUE;
break;
}
clutter_texture_get_base_size(CLUTTER_TEXTURE(texture), &iw, &ih);
clutter_actor_set_clip(texture, 0, 0, repeat_x ? w : iw, repeat_y ? h : ih);
clutter_texture_set_sync_size(CLUTTER_TEXTURE(texture), TRUE);
clutter_texture_set_repeat(CLUTTER_TEXTURE(texture), TRUE, TRUE);
clutter_texture_set_keep_aspect_ratio(CLUTTER_TEXTURE(texture), TRUE);
actor = texture;
clutter_actor_destroy(new_actor);
}
else {
actor = new_actor;
}
tool = TOOL_SELECT;
clutter_actor_add_action(actor, clutter_drag_action_new());
clutter_actor_set_reactive(actor, TRUE);
actors = g_list_append(actors, actor);
GdkWindow *gdk_window;
gdk_window = gtk_widget_get_window(app.stage);
gdk_window_set_cursor(gdk_window, NULL);
}
static void
mex_content_box_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
MexContentBox *self = MEX_CONTENT_BOX (object);
MexContentBoxPrivate *priv = self->priv;
switch (property_id)
{
case PROP_MEDIA_URL:
g_free (priv->media_url);
priv->media_url = g_value_dup_string (value);
break;
case PROP_LOGO_URL:
/* FIXME: We want the logo URL to be file:// to share the same
* underlying texture. This should be handled by a generic "download
* queue + texture cache" thingy that caches the same URL to a local
* file and hands over a ClutterTexure (or a MagicTexture) with the
* same underlying Cogl texture */
{
MxTextureCache *cache;
ClutterActor *logo, *logo_frame;
GFile *file;
gchar *path;
gint bw, bh;
gfloat ratio;
g_free (priv->logo_url);
priv->logo_url = g_value_dup_string (value);
if (priv->logo_url == NULL)
break;
file = g_file_new_for_uri (priv->logo_url);
path = g_file_get_path (file);
g_object_unref (file);
if (G_UNLIKELY (path == NULL))
{
g_warning ("The logo URL provided is not local, refusing to load it");
break;
}
cache = mx_texture_cache_get_default ();
logo = mx_texture_cache_get_actor (cache, path);
if (G_UNLIKELY (logo == NULL))
{
g_warning ("Could not retrieve texture for %s", path);
break;
}
logo_frame = mex_aspect_frame_new ();
/* FIXME, had to set the size (for now?) provides some GObject properties
* to tune that? expose it in the CSS */
clutter_actor_set_size (logo_frame, 60, 40);
clutter_texture_get_base_size (CLUTTER_TEXTURE (logo), &bw, &bh);
ratio = bh / 40.;
mex_aspect_frame_set_ratio (MEX_ASPECT_FRAME (logo_frame), ratio);
clutter_container_add_actor (CLUTTER_CONTAINER (logo_frame), logo);
mex_tile_set_primary_icon (MEX_TILE (priv->tile), logo_frame);
}
break;
case PROP_THUMB_WIDTH:
priv->thumb_width = g_value_get_int (value);
g_object_set (G_OBJECT (priv->tile),
"thumb-width",
priv->thumb_width,
NULL);
break;
case PROP_THUMB_HEIGHT:
priv->thumb_height = g_value_get_int (value);
g_object_set (G_OBJECT (priv->tile),
"thumb-height",
priv->thumb_height,
NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
}
