static ClutterActor *
mex_menu_item_new (MexMenu *self, MxAction *action, MexMenuActionType type)
{
ClutterActor *button, *layout, *icon, *vbox, *label, *arrow = NULL;
button = mx_button_new ();
mx_button_set_is_toggle (MX_BUTTON (button), TRUE);
mx_stylable_set_style_class (MX_STYLABLE (button), "Item");
layout = mx_box_layout_new ();
mx_bin_set_child (MX_BIN (button), layout);
mx_bin_set_fill (MX_BIN (button), TRUE, FALSE);
if (type == MEX_MENU_LEFT)
{
arrow = mx_icon_new ();
mx_stylable_set_style_class (MX_STYLABLE (arrow), "Left");
clutter_container_add_actor (CLUTTER_CONTAINER (layout), arrow);
}
vbox = mx_box_layout_new ();
mx_box_layout_set_orientation (MX_BOX_LAYOUT (vbox), MX_ORIENTATION_VERTICAL);
label = mx_label_new ();
mx_label_set_fade_out (MX_LABEL (label), TRUE);
mx_stylable_set_style_class (MX_STYLABLE (label), "Action");
g_object_bind_property (action, "display-name", label, "text",
G_BINDING_SYNC_CREATE);
clutter_container_add_actor (CLUTTER_CONTAINER (vbox), label);
label = mx_label_new ();
mx_label_set_fade_out (MX_LABEL (label), TRUE);
mx_stylable_set_style_class (MX_STYLABLE (label), "Detail");
clutter_container_add_actor (CLUTTER_CONTAINER (vbox), label);
clutter_actor_hide (label);
g_object_set_data (G_OBJECT (button), "detail-label", label);
clutter_container_add_actor (CLUTTER_CONTAINER (layout), vbox);
clutter_container_child_set (CLUTTER_CONTAINER (layout), vbox,
"expand", TRUE,
"x-fill", FALSE,
"x-align", MX_ALIGN_START,
"y-fill", FALSE,
NULL);
icon = mx_icon_new ();
g_object_bind_property (action, "icon", icon, "icon-name",
G_BINDING_SYNC_CREATE);
clutter_container_add_actor (CLUTTER_CONTAINER (layout), icon);
if (type == MEX_MENU_RIGHT)
{
arrow = mx_icon_new ();
mx_stylable_set_style_class (MX_STYLABLE (arrow), "Right");
clutter_container_add_actor (CLUTTER_CONTAINER (layout), arrow);
}
else if (type == MEX_MENU_TOGGLE)
{
ClutterActor *toggle = mx_icon_new ();
mx_stylable_set_style_class (MX_STYLABLE (toggle), "Toggle");
clutter_container_add_actor (CLUTTER_CONTAINER (layout), toggle);
g_object_set_data (G_OBJECT (button), "toggle-icon", toggle);
}
if (arrow)
clutter_container_child_set (CLUTTER_CONTAINER (layout),
arrow,
"expand", FALSE,
"y-align", MX_ALIGN_MIDDLE,
"y-fill", FALSE,
NULL);
g_signal_connect (button, "clicked",
G_CALLBACK (mex_menu_item_clicked_cb), action);
g_object_weak_ref (G_OBJECT (button),
(GWeakNotify)mex_menu_item_destroyed_cb,
self);
/* Set the item qdata on the button to mark that we created it */
g_object_set_qdata (G_OBJECT (button), mex_menu_item_quark,
GINT_TO_POINTER (TRUE));
return button;
}
static void
st_table_get_preferred_width (ClutterActor *self,
gfloat for_height,
gfloat *min_width_p,
gfloat *natural_width_p)
{
gint *min_widths, *pref_widths;
gfloat total_min_width, total_pref_width;
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gint i;
ClutterActor *child;
if (priv->n_cols < 1)
{
*min_width_p = 0;
*natural_width_p = 0;
return;
}
/* Setting size to zero and then what we want it to be causes a clear if
* clear flag is set (which it should be.)
*/
g_array_set_size (priv->min_widths, 0);
g_array_set_size (priv->pref_widths, 0);
g_array_set_size (priv->min_widths, priv->n_cols);
g_array_set_size (priv->pref_widths, priv->n_cols);
min_widths = (gint *) priv->min_widths->data;
pref_widths = (gint *) priv->pref_widths->data;
/* calculate minimum row widths */
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint col, col_span;
gfloat w_min, w_pref;
StTableChild *meta;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
col_span = meta->col_span;
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);
if (col_span == 1 && w_min > min_widths[col])
min_widths[col] = w_min;
if (col_span == 1 && w_pref > pref_widths[col])
pref_widths[col] = w_pref;
}
total_min_width = (priv->n_cols - 1) * (float) priv->col_spacing;
total_pref_width = total_min_width;
for (i = 0; i < priv->n_cols; i++)
{
total_min_width += min_widths[i];
total_pref_width += pref_widths[i];
}
/* If we were requested width-for-height, then we reported minimum/natural
* heights based on our natural width. If we were allocated less than our
* natural width, then we need more height. So in the width-for-height
* case we need to disable shrinking.
*/
if (for_height >= 0)
total_min_width = total_pref_width;
if (min_width_p)
*min_width_p = total_min_width;
if (natural_width_p)
*natural_width_p = total_pref_width;
st_theme_node_adjust_preferred_width (theme_node, min_width_p, natural_width_p);
}
void
test_cogl_vertex_buffer_contiguous (TestUtilsGTestFixture *fixture,
void *data)
{
TestState state;
ClutterActor *stage;
ClutterColor stage_clr = {0x0, 0x0, 0x0, 0xff};
ClutterActor *group;
unsigned int idle_source;
guchar tex_data[] = {
0xff, 0x00, 0x00, 0xff,
0xff, 0x00, 0x00, 0xff,
0x00, 0xff, 0x00, 0xff,
0x00, 0xff, 0x00, 0xff
};
stage = clutter_stage_get_default ();
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_clr);
clutter_actor_get_geometry (stage, &state.stage_geom);
group = clutter_group_new ();
clutter_actor_set_size (group,
state.stage_geom.width,
state.stage_geom.height);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group);
/* We force continuous redrawing incase someone comments out the
* clutter_main_quit and wants visual feedback for the test since we
* wont be doing anything else that will trigger redrawing. */
idle_source = g_idle_add (queue_redraw, stage);
g_signal_connect (group, "paint", G_CALLBACK (on_paint), &state);
state.texture = cogl_texture_new_from_data (2, 2,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888,
COGL_PIXEL_FORMAT_ANY,
0, /* auto calc row stride */
tex_data);
state.material = cogl_material_new ();
cogl_material_set_color4ub (state.material, 0x00, 0xff, 0x00, 0xff);
cogl_material_set_layer (state.material, 0, state.texture);
{
GLfloat triangle_verts[3][2] =
{
{0.0, 0.0},
{100.0, 100.0},
{0.0, 100.0}
};
GLbyte triangle_colors[3][4] =
{
{0x00, 0x00, 0xff, 0xff}, /* blue */
{0x00, 0x00, 0xff, 0x00}, /* transparent blue */
{0x00, 0x00, 0xff, 0x00} /* transparent blue */
};
GLfloat triangle_tex_coords[3][2] =
{
{0.0, 0.0},
{1.0, 1.0},
{0.0, 1.0}
};
state.buffer = cogl_vertex_buffer_new (3 /* n vertices */);
cogl_vertex_buffer_add (state.buffer,
"gl_Vertex",
2, /* n components */
GL_FLOAT,
FALSE, /* normalized */
0, /* stride */
triangle_verts);
cogl_vertex_buffer_add (state.buffer,
"gl_Color::blue",
4, /* n components */
GL_UNSIGNED_BYTE,
FALSE, /* normalized */
0, /* stride */
triangle_colors);
cogl_vertex_buffer_add (state.buffer,
"gl_MultiTexCoord0",
2, /* n components */
GL_FLOAT,
FALSE, /* normalized */
0, /* stride */
triangle_tex_coords);
cogl_vertex_buffer_submit (state.buffer);
}
clutter_actor_show_all (stage);
clutter_main ();
cogl_handle_unref (state.buffer);
cogl_handle_unref (state.material);
cogl_handle_unref (state.texture);
g_source_remove (idle_source);
if (g_test_verbose ())
g_print ("OK\n");
}
static void
st_table_homogeneous_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
gfloat col_width, row_height;
gint row_spacing, col_spacing;
StTablePrivate *priv = ST_TABLE (self)->priv;
gboolean ltr = clutter_actor_get_text_direction (self) == CLUTTER_TEXT_DIRECTION_LTR;
ClutterActor *child;
col_spacing = priv->col_spacing;
row_spacing = priv->row_spacing;
col_width = (int) ((content_box->x2 - content_box->x1
- (col_spacing * (priv->n_cols - 1)))
/ priv->n_cols + 0.5);
row_height = (int) ((content_box->y2 - content_box->y1
- (row_spacing * (priv->n_rows - 1)))
/ priv->n_rows + 0.5);
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, row_span, col_span;
StTableChild *meta;
ClutterActorBox childbox;
gdouble x_align_f, y_align_f;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
_st_get_align_factors (meta->x_align, meta->y_align,
&x_align_f, &y_align_f);
if (ltr)
{
childbox.x1 = content_box->x1 + (col_width + col_spacing) * col;
childbox.x2 = childbox.x1 + (col_width * col_span) + (col_spacing * (col_span - 1));
}
else
{
childbox.x2 = content_box->x2 - (col_width + col_spacing) * col;
childbox.x1 = childbox.x2 - (col_width * col_span) - (col_spacing * (col_span - 1));
}
childbox.y1 = content_box->y1 + (row_height + row_spacing) * row;
childbox.y2 = childbox.y1 + (row_height * row_span) + (row_spacing * (row_span - 1));
clutter_actor_allocate_align_fill (child, &childbox,
x_align_f, y_align_f,
meta->x_fill, meta->y_fill,
flags);
}
}
static gint *
st_table_calculate_row_heights (StTable *table,
gint for_height,
gint * col_widths)
{
StTablePrivate *priv = ST_TABLE (table)->priv;
gint *is_expand_row, *min_heights, *pref_heights, *row_heights, extra_row_height;
gint i, total_min_height;
gint expanded_rows = 0;
gint n_expanded_rows = 0;
ClutterActor *child;
g_array_set_size (priv->row_heights, 0);
g_array_set_size (priv->row_heights, priv->n_rows);
row_heights = (gboolean *) priv->row_heights->data;
g_array_set_size (priv->is_expand_row, 0);
g_array_set_size (priv->is_expand_row, priv->n_rows);
is_expand_row = (gboolean *) priv->is_expand_row->data;
g_array_set_size (priv->min_heights, 0);
g_array_set_size (priv->min_heights, priv->n_rows);
min_heights = (gboolean *) priv->min_heights->data;
g_array_set_size (priv->pref_heights, 0);
g_array_set_size (priv->pref_heights, priv->n_rows);
pref_heights = (gboolean *) priv->pref_heights->data;
for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (table));
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, cell_width;
gfloat h_min, h_pref;
gboolean y_expand;
StTableChild *meta;
gint col_span, row_span;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
y_expand = meta->y_expand;
col_span = meta->col_span;
row_span = meta->row_span;
if (y_expand)
is_expand_row[row] = TRUE;
/* calculate the cell width by including any spanned columns */
cell_width = 0;
for (i = 0; i < col_span && col + i < priv->n_cols; i++)
cell_width += (float)(col_widths[col + i]);
if (!meta->x_fill)
{
gfloat width;
_st_actor_get_preferred_width (child, -1, meta->y_fill, NULL, &width);
cell_width = MIN (cell_width, width);
}
_st_actor_get_preferred_height (child, cell_width, meta->x_fill,
&h_min, &h_pref);
if (row_span == 1 && h_pref > pref_heights[row])
{
pref_heights[row] = (int)(h_pref);
}
if (row_span == 1 && h_min > min_heights[row])
{
min_heights[row] = (int)(h_min);
}
}
total_min_height = 0; // priv->row_spacing * (priv->n_rows - 1);
for (i = 0; i < priv->n_rows; i++)
total_min_height += pref_heights[i];
/* calculate the remaining space and distribute it evenly onto all rows/cols
* with the x/y expand property set. */
for (i = 0; i < priv->n_rows; i++)
if (is_expand_row[i])
{
expanded_rows += pref_heights[i];
n_expanded_rows++;
}
/* extra row height = for height - row spacings - total_min_height */
for_height -= (priv->row_spacing * (priv->n_rows - 1));
extra_row_height = for_height - total_min_height;
if (extra_row_height < 0)
{
gint *skip = g_slice_alloc0 (sizeof (gint) * priv->n_rows);
gint total_shrink_height;
/* If we need to shrink rows, we need to do multiple passes.
*
* We start by assuming all rows can shrink. All rows are sized
* proportional to their height in the total table size. If a row would be
* sized smaller than its minimum size, we mark it as non-shrinkable, and
* reduce extra_row_height by the amount it has been shrunk. The amount
* it has been shrunk by is the difference between the preferred and
* minimum height, since all rows start at their preferred height. We
* also then reduce the total table size (stored in total_shrink_height) by the height
* of the row we are going to be skipping.
*
*/
/* We start by assuming all rows can shrink */
total_shrink_height = total_min_height;
for (i = 0; i < priv->n_rows; i++)
{
if (!skip[i])
{
gint tmp;
/* Calculate the height of the row by starting with the preferred
* height and taking away the extra row height proportional to
* the preferred row height over the rows that are being shrunk
*/
tmp = pref_heights[i]
+ (extra_row_height * (pref_heights[i] / (float) total_shrink_height));
if (tmp < min_heights[i])
{
/* This was a row we *were* set to shrink, but we now find it would have
* been shrunk too much. We remove it from the list of rows to shrink and
* adjust extra_row_height and total_shrink_height appropriately */
skip[i] = TRUE;
row_heights[i] = min_heights[i];
/* Reduce extra_row_height by the amount we have reduced this
* actor by */
extra_row_height += (pref_heights[i] - min_heights[i]);
/* now take off the row from the total shrink height */
total_shrink_height -= pref_heights[i];
/* restart the loop */
i = -1;
}
else
{
skip[i] = FALSE;
row_heights[i] = tmp;
}
}
}
g_slice_free1 (sizeof (gint) * priv->n_rows, skip);
}
else
{
for (i = 0; i < priv->n_rows; i++)
{
if (is_expand_row[i])
row_heights[i] = pref_heights[i] + (extra_row_height / n_expanded_rows);
else
row_heights[i] = pref_heights[i];
}
}
return row_heights;
}
int
main (int argc,
char **argv)
{
bool standalone = false;
char const *geometry = NULL;
int dpi = 0;
GOptionEntry _options[] = {
{ "standalone", 's', 0, G_OPTION_ARG_NONE, &standalone,
"Run as standalone app (for testing purpose)", NULL },
{ "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry,
"Window geometry in standalone mode", NULL },
#if CLUTTER_CHECK_VERSION(1, 3, 0)
{ "clutter-font-dpi", 'd', 0, G_OPTION_ARG_INT, &dpi,
"Set clutter font resolution to <dpi>", "<dpi>" },
#endif
{ NULL }
};
ClutterActor *shell;
GOptionContext *context;
ClutterInitError clutter_error;
GError *error = NULL;
setlocale (LC_ALL, "");
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
context = g_option_context_new ("- Dawati devices panel");
g_option_context_add_main_entries (context, _options, GETTEXT_PACKAGE);
g_option_context_add_group (context, clutter_get_option_group_without_init ());
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_critical ("%s %s", G_STRLOC, error->message);
g_critical ("Starting in standalone mode.");
g_clear_error (&error);
standalone = true;
}
g_option_context_free (context);
clutter_error = clutter_init (&argc, &argv);
if (clutter_error != CLUTTER_INIT_SUCCESS)
{
g_critical ("Unable to initialise clutter");
return EXIT_FAILURE;
}
notify_init (_("Dawati Devices Panel"));
/* Just for icon theme, no widgets. */
gtk_init (&argc, &argv);
if (dpi)
{
#if CLUTTER_CHECK_VERSION(1, 3, 0)
ClutterSettings *settings = clutter_settings_get_default ();
g_object_set (settings, "font-dpi", dpi * 1000, NULL);
#endif
}
/* Load base styling for default font size */
mpl_panel_clutter_load_base_style ();
mx_texture_cache_load_cache (mx_texture_cache_get_default (),
PKGDATADIR "/mx.cache");
mx_style_load_from_file (mx_style_get_default (),
THEMEDIR "/panel.css", NULL);
if (standalone)
{
ClutterActor *stage = clutter_stage_get_default ();
if (geometry)
{
int x, y;
unsigned int width, height;
XParseGeometry (geometry, &x, &y, &width, &height);
clutter_actor_set_size (stage, width, height);
} else
{
clutter_actor_set_size (stage, MPD_SHELL_WIDTH, MPD_SHELL_HEIGHT);
}
shell = mpd_shell_new ();
g_signal_connect (shell, "request-hide",
G_CALLBACK (_shell_request_hide_cb), NULL);
g_signal_connect (stage, "notify::width",
G_CALLBACK (_stage_width_notify_cb), shell);
g_signal_connect (stage, "notify::height",
G_CALLBACK (_stage_height_notify_cb), shell);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), shell);
clutter_actor_show_all (stage);
} else {
MplPanelClient *panel = mpd_panel_new ("devices",
_("devices"),
"devices-button");
shell = mpd_shell_new ();
mpd_shell_set_client (MPD_SHELL (shell), panel);
g_signal_connect (shell, "request-hide",
G_CALLBACK (_shell_request_hide_cb), panel);
g_signal_connect (shell, "request-show",
G_CALLBACK (_shell_request_show_cb), panel);
g_signal_connect (panel, "size-changed",
G_CALLBACK (_panel_set_size_cb), shell);
clutter_container_add_actor (CLUTTER_CONTAINER (panel), shell);
}
clutter_main ();
return EXIT_SUCCESS;
}
void
scene_prismatic_joint (Scene *scene)
{
ClutterActor *ground;
ClutterActor *group;
ClutterActor *prev_hand = NULL;
ClutterActor *first_hand = NULL;
ClutterActor *stage;
stage = clutter_stage_get_default ();
first_hand = ground = clutter_rectangle_new ();
clutter_actor_set_size (ground, 500, 120);
group = clutter_box2d_new ();
clutter_group_add (CLUTTER_GROUP (stage), group);
clutter_group_add (CLUTTER_GROUP (group), ground);
clutter_actor_set_position (ground, clutter_actor_get_width (
ground) * -0.3, 568); /*
this
is
wrong
*/
add_cage (group, TRUE);
ground = clutter_rectangle_new ();
clutter_actor_set_size (ground, 256, 3);
clutter_actor_set_position (ground, -100, 310);
clutter_actor_set_rotation (ground, CLUTTER_Z_AXIS, 30, 128, 16, 0);
clutter_group_add (CLUTTER_GROUP (group), ground);
clutter_container_child_set (CLUTTER_CONTAINER (group), ground,
"mode", CLUTTER_BOX2D_STATIC, NULL);
ground = clutter_rectangle_new ();
clutter_actor_set_size (ground, 256, 3);
clutter_actor_set_position (ground, 200, 200);
clutter_actor_set_rotation (ground, CLUTTER_Z_AXIS, -30, 0, 0, 0);
clutter_group_add (CLUTTER_GROUP (group), ground);
clutter_container_child_set (CLUTTER_CONTAINER (group), ground,
"mode", CLUTTER_BOX2D_STATIC, NULL);
/*add_hand (group, 100, 100);*/
prev_hand = add_hand (group, 200, 100);
if(0){
ClutterVertex anchor1 = { (0),
(0) };
ClutterVertex anchor2 = { (0),
(0) };
ClutterVertex axis = { (100.0),
(20.0) };
clutter_box2d_add_prismatic_joint (CLUTTER_BOX2D (group),
first_hand, prev_hand,
&anchor1, &anchor2,
200.0, 220.0, &axis);
}
clutter_actor_set_depth (group, -600);
clutter_actor_set_position (group, 0, -100);
clutter_actor_set_reactive (group, TRUE);
clutter_box2d_set_simulating (CLUTTER_BOX2D (group), simulating);
scene->group = group;
}
int
main (int argc, char *argv[])
{
GError *error = NULL;
/* UI */
ClutterActor *stage;
ClutterLayoutManager *layout;
ClutterActor *box;
ClutterActor *top, *bottom;
ClutterState *transitions;
clutter_init_with_args (&argc, &argv,
" - cross-fade", entries,
NULL,
NULL);
if (source == NULL || target == NULL)
{
g_print ("Usage: %s -s <source> -t <target> [-d <duration>]\n", argv[0]);
exit (EXIT_FAILURE);
}
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "cross-fade");
clutter_actor_set_size (stage, 400, 300);
clutter_actor_show (stage);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
box = clutter_box_new (layout);
clutter_actor_set_size (box, 400, 300);
bottom = clutter_texture_new ();
top = clutter_texture_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (box), bottom);
clutter_container_add_actor (CLUTTER_CONTAINER (box), top);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
/* load the first image into the bottom */
load_image (CLUTTER_TEXTURE (bottom), source);
/* load the second image into the top */
load_image (CLUTTER_TEXTURE (top), target);
/* animations */
transitions = clutter_state_new ();
clutter_state_set (transitions, NULL, "show-bottom",
top, "opacity", CLUTTER_LINEAR, 0,
bottom, "opacity", CLUTTER_LINEAR, 255,
NULL);
clutter_state_set (transitions, NULL, "show-top",
top, "opacity", CLUTTER_EASE_IN_CUBIC, 255,
bottom, "opacity", CLUTTER_EASE_IN_CUBIC, 0,
NULL);
clutter_state_set_duration (transitions, NULL, NULL, duration);
/* make the bottom opaque and top transparent */
clutter_state_warp_to_state (transitions, "show-bottom");
/* on key press, fade in the top texture and fade out the bottom texture */
g_signal_connect (stage,
"key-press-event",
G_CALLBACK (start_animation),
transitions);
clutter_actor_show (stage);
clutter_main ();
g_object_unref (transitions);
if (error != NULL)
g_error_free (error);
return EXIT_SUCCESS;
}
static void
contact_widget_location_update (EmpathyContactWidget *information)
{
GHashTable *location;
GValue *value;
gdouble lat = 0.0, lon = 0.0;
gboolean has_position = TRUE;
GtkWidget *label;
guint row = 0;
static const gchar* ordered_geolocation_keys[] = {
EMPATHY_LOCATION_TEXT,
EMPATHY_LOCATION_URI,
EMPATHY_LOCATION_DESCRIPTION,
EMPATHY_LOCATION_BUILDING,
EMPATHY_LOCATION_FLOOR,
EMPATHY_LOCATION_ROOM,
EMPATHY_LOCATION_STREET,
EMPATHY_LOCATION_AREA,
EMPATHY_LOCATION_LOCALITY,
EMPATHY_LOCATION_REGION,
EMPATHY_LOCATION_COUNTRY,
NULL
};
int i;
const gchar *skey;
gboolean display_map = FALSE;
if (!(information->flags & EMPATHY_CONTACT_WIDGET_SHOW_LOCATION))
{
gtk_widget_hide (information->vbox_location);
return;
}
location = empathy_contact_get_location (information->contact);
if (location == NULL || g_hash_table_size (location) == 0)
{
gtk_widget_hide (information->vbox_location);
return;
}
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LAT);
if (value == NULL)
has_position = FALSE;
else
lat = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_LON);
if (value == NULL)
has_position = FALSE;
else
lon = g_value_get_double (value);
value = g_hash_table_lookup (location, EMPATHY_LOCATION_TIMESTAMP);
if (value == NULL)
{
gchar *loc = g_strdup_printf ("<b>%s</b>", _("Location"));
gtk_label_set_markup (GTK_LABEL (information->label_location), loc);
g_free (loc);
}
else
{
gchar *user_date;
gchar *text;
gint64 stamp;
time_t time_;
stamp = g_value_get_int64 (value);
time_ = stamp;
user_date = empathy_time_to_string_relative (time_);
text = g_strconcat ( _("<b>Location</b>, "), user_date, NULL);
gtk_label_set_markup (GTK_LABEL (information->label_location), text);
g_free (text);
}
/* Prepare the location information table */
if (information->table_location != NULL)
{
gtk_widget_destroy (information->table_location);
}
information->table_location = gtk_table_new (1, 2, FALSE);
gtk_box_pack_start (GTK_BOX (information->subvbox_location),
information->table_location, FALSE, FALSE, 5);
for (i = 0; (skey = ordered_geolocation_keys[i]); i++)
{
const gchar* user_label;
GValue *gvalue;
char *svalue = NULL;
gvalue = g_hash_table_lookup (location, (gpointer) skey);
if (gvalue == NULL)
continue;
user_label = location_key_to_label (skey);
label = gtk_label_new (user_label);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (information->table_location),
label, 0, 1, row, row + 1, GTK_FILL, GTK_FILL, 10, 0);
gtk_widget_show (label);
if (G_VALUE_TYPE (gvalue) == G_TYPE_DOUBLE)
{
gdouble dvalue;
dvalue = g_value_get_double (gvalue);
svalue = g_strdup_printf ("%f", dvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_STRING)
{
svalue = g_value_dup_string (gvalue);
}
else if (G_VALUE_TYPE (gvalue) == G_TYPE_INT64)
{
time_t time_;
time_ = g_value_get_int64 (value);
svalue = empathy_time_to_string_utc (time_, _("%B %e, %Y at %R UTC"));
}
if (svalue != NULL)
{
label = gtk_label_new (svalue);
gtk_table_attach_defaults (GTK_TABLE (information->table_location),
label, 1, 2, row, row + 1);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
gtk_widget_show (label);
if (!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
}
g_free (svalue);
row++;
}
#if HAVE_LIBCHAMPLAIN
if (has_position &&
!(information->flags & EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP))
{
/* Cannot be displayed in tooltips until Clutter-Gtk can deal with such
* windows */
display_map = TRUE;
}
#endif
if (row > 0)
{
/* We can display some fields */
gtk_widget_show (information->table_location);
}
else if (!display_map)
{
/* Can't display either fields or map */
gtk_widget_hide (information->vbox_location);
return;
}
#if HAVE_LIBCHAMPLAIN
if (display_map)
{
ClutterActor *marker;
ChamplainLayer *layer;
information->map_view_embed = gtk_champlain_embed_new ();
information->map_view = gtk_champlain_embed_get_view (
GTK_CHAMPLAIN_EMBED (information->map_view_embed));
gtk_container_add (GTK_CONTAINER (information->viewport_map),
information->map_view_embed);
g_object_set (G_OBJECT (information->map_view),
"show-license", TRUE,
"scroll-mode", CHAMPLAIN_SCROLL_MODE_KINETIC,
"zoom-level", 10,
NULL);
layer = champlain_layer_new ();
champlain_view_add_layer (information->map_view, layer);
marker = champlain_marker_new_with_text (
empathy_contact_get_name (information->contact), NULL, NULL, NULL);
champlain_base_marker_set_position (CHAMPLAIN_BASE_MARKER (marker), lat, lon);
clutter_container_add (CLUTTER_CONTAINER (layer), marker, NULL);
champlain_view_center_on (information->map_view, lat, lon);
gtk_widget_show_all (information->viewport_map);
}
#endif
gtk_widget_show (information->vbox_location);
}
static void
_update_layout (PengeGridView *grid_view)
{
PengeGridViewPrivate *priv = GET_PRIVATE (grid_view);
gint col = 0;
if (priv->vertical_apps)
{
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->favourite_apps_pane,
"column", col,
"row", 1,
"y-expand", TRUE,
"y-fill", FALSE,
"y-align", MX_ALIGN_START,
"x-align", MX_ALIGN_START,
"x-expand", FALSE,
"x-fill", FALSE,
NULL);
if (priv->show_calendar_pane)
{
col++;
clutter_actor_show (priv->calendar_pane);
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->calendar_pane,
"column", col,
"x-expand", FALSE,
"y-fill", FALSE,
"y-align", MX_ALIGN_START,
NULL);
} else {
clutter_actor_hide (priv->calendar_pane);
}
if (priv->show_email_pane)
{
clutter_actor_show (priv->email_pane);
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->email_pane,
"column", col,
"y-expand", TRUE,
"y-fill", FALSE,
"y-align", MX_ALIGN_END,
"x-align", MX_ALIGN_MIDDLE,
"x-expand", FALSE,
"x-fill", FALSE,
NULL);
col++;
} else {
clutter_actor_hide (priv->email_pane);
}
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->div_tex,
"row-span", 1,
"column", col,
"x-expand", FALSE,
NULL);
col++;
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->everything_pane,
"row-span", 1,
"column", col,
"x-expand", TRUE,
"x-fill", TRUE,
"y-expand", TRUE,
"y-fill", TRUE,
NULL);
if (priv->show_email_pane)
{
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->everything_pane,
"row-span", 2,
NULL);
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->div_tex,
"row-span", 2,
NULL);
} else {
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->everything_pane,
"row-span", 1,
NULL);
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->div_tex,
"row-span", 1,
NULL);
}
g_object_set (priv->favourite_apps_pane,
"vertical", TRUE,
NULL);
if (!priv->show_calendar_pane)
g_object_set (priv->email_pane,
"vertical", TRUE,
NULL);
else
g_object_set (priv->email_pane,
"vertical", FALSE,
NULL);
clutter_actor_queue_relayout (CLUTTER_ACTOR (grid_view));
} else {
if (priv->show_calendar_pane)
{
clutter_actor_show (priv->calendar_pane);
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->calendar_pane,
"column", col,
"x-expand", FALSE,
"y-expand", FALSE,
"y-fill", FALSE,
NULL);
} else {
clutter_actor_hide (priv->calendar_pane);
}
if (priv->show_email_pane)
{
clutter_actor_show (priv->email_pane);
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->email_pane,
"column", col,
"x-expand", FALSE,
"y-expand", TRUE,
"y-fill", FALSE,
"y-align", MX_ALIGN_END,
NULL);
} else {
clutter_actor_hide (priv->email_pane);
}
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->favourite_apps_pane,
"column", col,
"row", 3,
"x-expand", FALSE,
"x-fill", TRUE,
"y-fill", FALSE,
"y-align", MX_ALIGN_END,
NULL);
/* If we are showing the email then it is responsible for expanding to fill
* the area. Otherwise the favourites app pane is responsible.
*/
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->favourite_apps_pane,
"y-expand", !priv->show_email_pane,
NULL);
col++;
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->div_tex,
"row-span", 3,
"column", col,
"x-expand", FALSE,
NULL);
col++;
clutter_container_child_set (CLUTTER_CONTAINER (grid_view),
priv->everything_pane,
"row-span", 3,
"column", col,
"x-expand", TRUE,
"x-fill", TRUE,
"y-expand", TRUE,
"y-fill", TRUE,
NULL);
g_object_set (priv->favourite_apps_pane,
"vertical", FALSE,
NULL);
g_object_set (priv->email_pane,
"vertical", FALSE,
NULL);
clutter_actor_queue_relayout (CLUTTER_ACTOR (grid_view));
}
}
int
main (int argc,
char *argv[])
{
ClutterActor *stage;
ClutterActor *texture;
ClutterEffect *effect;
ClutterState *transitions;
GError *error = NULL;
gchar *filename;
if (argc < 2)
{
g_print ("Usage: %s <path to image file>\n", argv[0]);
return EXIT_FAILURE;
}
filename = argv[1];
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 400, 300);
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
texture = clutter_texture_new ();
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);
clutter_actor_set_width (texture, 400);
clutter_actor_set_reactive (texture, TRUE);
clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
filename,
&error);
if (error != NULL)
{
g_critical ("Error loading texture from file %s; error was:\n%s",
filename,
error->message);
return EXIT_FAILURE;
}
/* create the page fold effect instance with destination fold angle
* of 180 degrees and starting period of 0 (no folding)
*/
effect = cb_page_fold_effect_new (180.0, 0.0);
/* add the effect to the texture actor */
clutter_actor_add_effect (texture, effect);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);
/* animation for the period property of the effect,
* to animate its value between 0.0 and 1.0 and back
*/
transitions = clutter_state_new ();
clutter_state_set_duration (transitions, NULL, NULL, 500);
clutter_state_set_duration (transitions,
"partially-folded",
"folded",
375);
clutter_state_set (transitions, NULL, "folded",
effect, "period", CLUTTER_LINEAR, 1.0,
NULL);
clutter_state_set (transitions, NULL, "partially-folded",
effect, "period", CLUTTER_LINEAR, 0.25,
NULL);
clutter_state_set (transitions, NULL, "unfolded",
effect, "period", CLUTTER_LINEAR, 0.0,
NULL);
clutter_state_warp_to_state (transitions, "partially-folded");
g_signal_connect (texture,
"button-press-event",
G_CALLBACK (button_pressed_cb),
transitions);
clutter_actor_show (stage);
clutter_main ();
g_object_unref (transitions);
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
ClutterActor *stage = stage;
ClutterActor *side_box;
ClutterActor *button_box;
ClutterActor *box;
ClutterAnimation *anim;
MashLightSet *light_set;
MxStyle *style;
GError *error = NULL;
Data data;
int i;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
style = mx_style_get_default ();
if (!mx_style_load_from_file (style, "lights.css",
&error))
{
g_warning ("Error setting style: %s", error->message);
g_clear_error (&error);
}
stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, 800, 600);
side_box = mx_table_new ();
clutter_actor_set_name (side_box, "side-box");
clutter_container_add_actor (CLUTTER_CONTAINER (stage), side_box);
clutter_actor_set_size (side_box, 300,
clutter_actor_get_height (stage));
clutter_actor_set_x (side_box,
clutter_actor_get_width (stage)
- clutter_actor_get_width (side_box));
button_box = mx_table_new ();
mx_table_add_actor (MX_TABLE (side_box), button_box, 0, 0);
data.notebook = mx_notebook_new ();
mx_table_add_actor (MX_TABLE (side_box), data.notebook, 1, 0);
data.model = mash_model_new_from_file (MASH_DATA_NONE,
argc > 1
? argv[1]
: "suzanne.ply",
&error);
if (data.model == NULL)
{
g_warning ("Error loading model: %s", error->message);
g_clear_error (&error);
return 1;
}
light_set = mash_light_set_new ();
box = clutter_box_new (clutter_fixed_layout_new ());
clutter_actor_set_size (data.model, 400, 400);
clutter_actor_set_position (data.model, 50.0, 100.0);
clutter_container_add_actor (CLUTTER_CONTAINER (box), data.model);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
g_signal_connect_swapped (box, "paint",
G_CALLBACK (cogl_set_depth_test_enabled),
GINT_TO_POINTER (TRUE));
g_signal_connect_data (box, "paint",
G_CALLBACK (cogl_set_depth_test_enabled),
GINT_TO_POINTER (FALSE), NULL,
G_CONNECT_AFTER | G_CONNECT_SWAPPED);
data.light_marker_material = cogl_material_new ();
{
CoglColor color;
cogl_color_set_from_4ub (&color, 255, 0, 0, 255);
/* Use the layer state to ignore the vertex color from the shader so
that the light marker won't itself be lit */
cogl_material_set_layer_combine_constant (data.light_marker_material, 0,
&color);
cogl_material_set_layer_combine (data.light_marker_material, 0,
"RGBA = REPLACE(CONSTANT)",
NULL);
}
clutter_actor_set_rotation (data.model, CLUTTER_Y_AXIS,
0.0f,
clutter_actor_get_width (data.model) / 2.0f,
0.0f,
0.0f);
anim = clutter_actor_animate (data.model, CLUTTER_LINEAR, 3000,
"rotation-angle-y", 360.0f,
NULL);
clutter_animation_set_loop (anim, TRUE);
for (i = 0; i < N_LIGHTS; i++)
{
ClutterActor *table = mx_table_new ();
ClutterActor *button;
static ClutterActor *(* constructors[N_LIGHTS]) (void) =
{ mash_directional_light_new,
mash_point_light_new,
mash_spot_light_new };
static const ClutterColor black = { 0, 0, 0, 255 };
data.lights[i] = constructors[i] ();
button = mx_button_new_with_label (G_OBJECT_TYPE_NAME (data.lights[i]));
mx_table_add_actor (MX_TABLE (button_box), button, i, 0);
/* Default to disable all of the lights */
g_object_set (data.lights[i],
"ambient", &black,
"diffuse", &black,
"specular", &black,
NULL);
data.notebook_buttons[i] = button;
clutter_container_add_actor (CLUTTER_CONTAINER (box), data.lights[i]);
mash_light_set_add_light (light_set, MASH_LIGHT (data.lights[i]));
add_color_prop (table, "ambient light",
G_OBJECT (data.lights[i]), "ambient");
add_color_prop (table, "diffuse light",
G_OBJECT (data.lights[i]), "diffuse");
add_color_prop (table, "specular light",
G_OBJECT (data.lights[i]), "specular");
if (MASH_IS_POINT_LIGHT (data.lights[i]))
{
add_float_prop (table, "constant attenuation",
G_OBJECT (data.lights[i]), "constant-attenuation",
0.0f, 10.0f);
add_float_prop (table, "linear attenuation",
G_OBJECT (data.lights[i]), "linear-attenuation",
0.0f, 10.0f);
add_float_prop (table, "quadratic attenuation",
G_OBJECT (data.lights[i]), "quadratic-attenuation",
0.0f, 10.0f);
}
if (MASH_IS_SPOT_LIGHT (data.lights[i]))
{
clutter_actor_set_x (data.lights[i], 250);
add_float_prop (table, "spot cutoff",
G_OBJECT (data.lights[i]), "spot-cutoff",
0.0f, 90.0f);
add_float_prop (table, "spot exponent",
G_OBJECT (data.lights[i]), "spot-exponent",
0.0f, 128.0f);
}
clutter_container_add_actor (CLUTTER_CONTAINER (data.notebook), table);
data.notebook_pages[i] = table;
}
{
ClutterActor *button;
ClutterActor *table;
CoglHandle material;
float maximum_shininess;
material = mash_model_get_material (MASH_MODEL (data.model));
/* Before version 1.3.10 on the 1.3 branch and 1.2.14 on the 1.2
branch Cogl would remap the shininess property to the range
[0,1]. After this it is just a value greater or equal to zero
(but GL imposes a limit of 128.0) */
if (clutter_check_version (1, 3, 9)
|| (clutter_major_version == 1
&& clutter_minor_version == 2
&& clutter_micro_version >= 13))
maximum_shininess = 128.0f;
else
maximum_shininess = 1.0f;
cogl_material_set_shininess (material, maximum_shininess);
button = mx_button_new_with_label ("Material");
data.notebook_buttons[i] = button;
mx_table_add_actor (MX_TABLE (button_box), button, i, 0);
table = mx_table_new ();
data.notebook_pages[i] = table;
clutter_container_add_actor (CLUTTER_CONTAINER (data.notebook), table);
add_material_color_prop (table, "emission", material,
cogl_material_set_emission,
cogl_material_get_emission);
add_material_color_prop (table, "diffuse", material,
cogl_material_set_diffuse,
cogl_material_get_diffuse);
add_material_color_prop (table, "ambient", material,
cogl_material_set_ambient,
cogl_material_get_ambient);
add_material_color_prop (table, "specular", material,
cogl_material_set_specular,
cogl_material_get_specular);
add_material_float_prop (table, "shininess", material,
0.0f, maximum_shininess,
cogl_material_set_shininess,
cogl_material_get_shininess);
}
mash_model_set_light_set (MASH_MODEL (data.model), light_set);
g_object_unref (light_set);
for (i = 0; i < N_PAGES; i++)
{
g_signal_connect (data.notebook_buttons[i], "notify::toggled",
G_CALLBACK (notebook_button_cb), &data);
mx_button_set_is_toggle (MX_BUTTON (data.notebook_buttons[i]), TRUE);
}
mx_button_set_toggled (MX_BUTTON (data.notebook_buttons[0]), TRUE);
g_signal_connect (stage, "motion-event",
G_CALLBACK (motion_event_cb),
&data);
clutter_actor_show (stage);
clutter_main ();
cogl_handle_unref (data.light_marker_material);
return 0;
}
G_MODULE_EXPORT int
test_bin_layout_main (int argc, char *argv[])
{
ClutterActor *stage, *box, *rect;
ClutterLayoutManager *layout;
ClutterColor stage_color = { 0xe0, 0xf2, 0xfc, 0xff };
ClutterColor bg_color = { 0xcc, 0xcc, 0xcc, 0x99 };
ClutterColor *color;
clutter_init (&argc, &argv);
stage = clutter_stage_get_default ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Box test");
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
clutter_actor_set_size (stage, 640, 480);
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
box = clutter_box_new (layout);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
clutter_actor_set_anchor_point_from_gravity (box, CLUTTER_GRAVITY_CENTER);
clutter_actor_set_position (box, 320, 240);
clutter_actor_set_reactive (box, TRUE);
clutter_actor_set_name (box, "box");
rect = make_background (&bg_color, 200, 200);
/* first method: use clutter_box_pack() */
clutter_box_pack (CLUTTER_BOX (box), rect,
"x-align", CLUTTER_BIN_ALIGNMENT_FILL,
"y-align", CLUTTER_BIN_ALIGNMENT_FILL,
NULL);
clutter_actor_lower_bottom (rect);
clutter_actor_set_name (rect, "background");
{
ClutterActor *tex;
GError *error;
gchar *file;
error = NULL;
file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL);
tex = clutter_texture_new_from_file (file, &error);
if (error)
g_error ("Unable to create texture: %s", error->message);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (tex), TRUE);
/* second method: use clutter_bin_layout_add() */
clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout), tex,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
clutter_actor_raise (tex, rect);
clutter_actor_set_width (tex, 175);
clutter_actor_set_name (tex, "texture");
g_free (file);
}
color = clutter_color_new (g_random_int_range (0, 255),
g_random_int_range (0, 255),
g_random_int_range (0, 255),
224);
rect = clutter_rectangle_new_with_color (color);
/* third method: container_add() and set_alignment() */
clutter_container_add_actor (CLUTTER_CONTAINER (box), rect);
clutter_bin_layout_set_alignment (CLUTTER_BIN_LAYOUT (layout), rect,
CLUTTER_BIN_ALIGNMENT_END,
CLUTTER_BIN_ALIGNMENT_END);
clutter_actor_set_size (rect, 50, 50);
clutter_actor_set_opacity (rect, 0);
clutter_actor_raise_top (rect);
clutter_actor_set_name (rect, "emblem");
g_signal_connect (box,
"enter-event", G_CALLBACK (on_box_enter),
rect);
g_signal_connect (box,
"leave-event", G_CALLBACK (on_box_leave),
rect);
clutter_actor_show_all (stage);
clutter_main ();
clutter_color_free (color);
return EXIT_SUCCESS;
}
static void
mex_media_controls_init (MexMediaControls *self)
{
ClutterActor *actor;
ClutterScript *script;
GError *err = NULL;
MxAdjustment *adjustment;
ClutterActor *related_box;
gchar *tmp;
MexMediaControlsPrivate *priv = self->priv = MEDIA_CONTROLS_PRIVATE (self);
priv->script = script = clutter_script_new ();
tmp = g_build_filename (mex_get_data_dir (), "json", "media-controls.json",
NULL);
clutter_script_load_from_file (script, tmp, &err);
g_free (tmp);
if (err)
g_error ("Could not load media controls interface: %s", err->message);
priv->vbox =
(ClutterActor*) clutter_script_get_object (script, "media-controls");
clutter_actor_set_parent (priv->vbox, CLUTTER_ACTOR (self));
/* add shadow to media controls box */
actor = (ClutterActor *) clutter_script_get_object (script,
"media-controls-box");
clutter_actor_add_effect (actor, CLUTTER_EFFECT (mex_shadow_new ()));
/* vertical fade effect */
priv->vertical_effect = mx_fade_effect_new ();
clutter_actor_add_effect (priv->vbox, priv->vertical_effect);
mx_scrollable_get_adjustments (MX_SCROLLABLE (mx_bin_get_child (MX_BIN (priv->vbox))),
NULL, &adjustment);
g_signal_connect (adjustment, "changed",
G_CALLBACK (notify_vertical_changed_cb), self);
g_signal_connect (adjustment, "notify::value",
G_CALLBACK (notify_vertical_value_cb), self);
/* horizontal fade effect */
priv->horizontal_effect = mx_fade_effect_new ();
related_box = (ClutterActor *) clutter_script_get_object (priv->script,
"related-box");
clutter_actor_add_effect (related_box, priv->horizontal_effect);
mx_scrollable_get_adjustments (MX_SCROLLABLE (related_box), &adjustment,
NULL);
g_signal_connect (adjustment, "changed",
G_CALLBACK (notify_horizontal_changed_cb), self);
g_signal_connect (adjustment, "notify::value",
G_CALLBACK (notify_horizontal_value_cb), self);
/* slider setup */
priv->slider = (ClutterActor*) clutter_script_get_object (script, "slider");
g_signal_connect (priv->slider, "notify::value",
G_CALLBACK (slider_value_changed_cb), self);
g_signal_connect (priv->slider, "captured-event",
G_CALLBACK (slider_captured_event), self);
priv->play_pause_action =
(MxAction*) clutter_script_get_object (script, "play-pause-action");
priv->stop_action =
(MxAction*) clutter_script_get_object (script, "stop-action");
priv->add_to_queue_action =
(MxAction*) clutter_script_get_object (script, "add-to-queue-action");
priv->queue_button =
(ClutterActor *) clutter_script_get_object (script, "add-to-queue-button");
g_signal_connect (priv->play_pause_action, "activated",
G_CALLBACK (mex_media_controls_play_cb), self);
g_signal_connect (priv->stop_action, "activated",
G_CALLBACK (mex_media_controls_stop_cb), self);
#if 0
g_signal_connect (priv->add_to_queue_action, "activated",
G_CALLBACK (mex_media_controls_add_to_queue_cb), self);
#endif
/* proxy setup */
priv->proxy_model = MEX_VIEW_MODEL (mex_view_model_new (NULL));
/* FIXME: Set an arbitrary 200-item limit as we can't handle large
* amounts of actors without massive slow-down.
*/
mex_view_model_set_limit (priv->proxy_model, 200);
priv->proxy = mex_content_proxy_new (MEX_MODEL (priv->proxy_model),
CLUTTER_CONTAINER (related_box),
MEX_TYPE_CONTENT_TILE);
g_signal_connect (priv->proxy, "object-created", G_CALLBACK (tile_created_cb),
self);
priv->is_disabled = TRUE;
}
/**
* clutter_box_packv:
* @box: a #ClutterBox
* @actor: a #ClutterActor
* @n_properties: the number of properties to set
* @properties: (array length=n_properties) (element-type utf8): a vector
* containing the property names to set
* @values: (array length=n_properties): a vector containing the property
* values to set
*
* Vector-based variant of clutter_box_pack(), intended for language
* bindings to use
*
* Since: 1.2
*/
void
clutter_box_packv (ClutterBox *box,
ClutterActor *actor,
guint n_properties,
const gchar * const properties[],
const GValue *values)
{
ClutterContainer *container;
ClutterBoxPrivate *priv;
ClutterLayoutMeta *meta;
GObjectClass *klass;
gint i;
g_return_if_fail (CLUTTER_IS_BOX (box));
g_return_if_fail (CLUTTER_IS_ACTOR (actor));
container = CLUTTER_CONTAINER (box);
clutter_container_add_actor (container, actor);
priv = box->priv;
meta = clutter_layout_manager_get_child_meta (priv->manager,
container,
actor);
if (meta == NULL)
return;
klass = G_OBJECT_GET_CLASS (meta);
for (i = 0; i < n_properties; i++)
{
const gchar *pname = properties[i];
GParamSpec *pspec;
pspec = g_object_class_find_property (klass, pname);
if (pspec == NULL)
{
g_warning ("%s: the layout property '%s' for managers "
"of type '%s' (meta type '%s') does not exist",
G_STRLOC,
pname,
G_OBJECT_TYPE_NAME (priv->manager),
G_OBJECT_TYPE_NAME (meta));
break;
}
if (!(pspec->flags & G_PARAM_WRITABLE))
{
g_warning ("%s: the layout property '%s' for managers "
"of type '%s' (meta type '%s') is not writable",
G_STRLOC,
pspec->name,
G_OBJECT_TYPE_NAME (priv->manager),
G_OBJECT_TYPE_NAME (meta));
break;
}
clutter_layout_manager_child_set_property (priv->manager,
container, actor,
pname, &values[i]);
}
}
static void manager_event_object_new(unsigned short type, void *userdata, void *data)
{
na_scene_actor_t *actor;
tuio_object_t *o = (tuio_object_t *)data;
manager_actor_t *el;
ClutterActor *stage;
uint wx,
wy;
assert( data != NULL );
/* search actor from scene
*/
actor = na_scene_actor_get(c_scene, o->f_id);
if ( actor == NULL )
{
l_errorf("actor %d not found in scene", o->f_id);
return;
}
/* check rendering module
*/
if ( actor->mod == NULL )
{
l_errorf("no object associated for actor %d", o->f_id);
return;
}
/* create manager actor
*/
el = malloc(sizeof(struct manager_actor_s));
if ( el == NULL )
{
l_errorf("no enough memory to create manager actor");
return;
}
bzero(el, sizeof(struct manager_actor_s));
el->id = o->s_id;
el->tuio = o;
el->scene_actor = actor;
el->clutter_actor = clutter_group_new();
el->rotate_actor = clutter_group_new();
clutter_container_add_actor(CLUTTER_CONTAINER(el->clutter_actor), el->rotate_actor);
/* use associed module for rendering
*/
(*actor->mod->object_prepare)(actor->data_mod, el);
/* insert actor into list
*/
LIST_INSERT_HEAD(&manager_actors_list, el, next);
/* retreive last dimensions
*/
stage = clutter_stage_get_default();
clutter_actor_get_size(stage, &wx, &wy);
/* some position
*/
clutter_actor_set_position(el->clutter_actor,
o->xpos * (float)wx,
o->ypos * (float)wy
);
clutter_actor_set_rotation(el->rotate_actor,
CLUTTER_Z_AXIS,
TUIO_PI_TO_DEG(o->angle),
actor->width * 0.5,
actor->height * 0.5,
0
);
/* show actor
* FIXME not needed ?
*/
clutter_actor_show(el->clutter_actor);
/* add to stage
*/
clutter_container_add_actor(CLUTTER_CONTAINER(stage), el->clutter_actor);
atomic_set(&c_scene_changed, 1);
}
static inline void
clutter_box_set_property_valist (ClutterBox *box,
ClutterActor *actor,
const gchar *first_property,
va_list var_args)
{
ClutterContainer *container = CLUTTER_CONTAINER (box);
ClutterBoxPrivate *priv = box->priv;
ClutterLayoutMeta *meta;
GObjectClass *klass;
const gchar *pname;
if (priv->manager == NULL)
return;
meta = clutter_layout_manager_get_child_meta (priv->manager,
container,
actor);
if (meta == NULL)
return;
klass = G_OBJECT_GET_CLASS (meta);
pname = first_property;
while (pname)
{
GValue value = { 0, };
GParamSpec *pspec;
gchar *error;
pspec = g_object_class_find_property (klass, pname);
if (pspec == NULL)
{
g_warning ("%s: the layout property '%s' for managers "
"of type '%s' (meta type '%s') does not exist",
G_STRLOC,
pname,
G_OBJECT_TYPE_NAME (priv->manager),
G_OBJECT_TYPE_NAME (meta));
break;
}
if (!(pspec->flags & G_PARAM_WRITABLE))
{
g_warning ("%s: the layout property '%s' for managers "
"of type '%s' (meta type '%s') is not writable",
G_STRLOC,
pspec->name,
G_OBJECT_TYPE_NAME (priv->manager),
G_OBJECT_TYPE_NAME (meta));
break;
}
G_VALUE_COLLECT_INIT (&value, G_PARAM_SPEC_VALUE_TYPE (pspec),
var_args, 0,
&error);
if (error)
{
g_warning ("%s: %s", G_STRLOC, error);
g_free (error);
break;
}
clutter_layout_manager_child_set_property (priv->manager,
container, actor,
pspec->name, &value);
g_value_unset (&value);
pname = va_arg (var_args, gchar*);
}
}
static void
penge_welcome_tile_init (PengeWelcomeTile *tile)
{
ClutterActor *placeholder_image;
GError *error = NULL;
placeholder_image = clutter_texture_new_from_file (PLACEHOLDER_IMAGE, &error);
if (error != NULL)
{
g_warning ("Couldn't open the placeholder image %s", PLACEHOLDER_IMAGE);
g_clear_error (&error);
}
else
{
ClutterActor *bin;
bin = mx_frame_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (bin),
placeholder_image);
clutter_actor_set_name (bin,
"penge-welcome-placeholder-margin");
clutter_actor_set_name (placeholder_image,
"penge-welcome-placeholder");
clutter_actor_set_size (placeholder_image, 548, 247);
mx_table_insert_actor_with_properties (MX_TABLE (tile),
bin,
0, 0,
"x-expand", TRUE,
"y-expand", TRUE,
"x-fill", TRUE,
"y-fill", TRUE,
"x-align", MX_ALIGN_START,
NULL);
mx_bin_set_fill (MX_BIN (bin), TRUE, TRUE);
}
/* It's not to be shown
if (g_file_test (WELCOME_VIDEO_FILENAME, G_FILE_TEST_EXISTS))
{
ClutterActor *launcher;
ClutterActor *inner_table;
ClutterActor *icon;
launcher = mx_button_new ();
clutter_actor_set_name (launcher, "penge-welcome-launcher");
inner_table = mx_table_new ();
mx_bin_set_child (MX_BIN (launcher), inner_table);
icon = mx_icon_new ();
clutter_actor_set_name (icon, "penge-welcome-launcher-thumbnail");
mx_table_insert_actor_with_properties (MX_TABLE (inner_table),
icon,
0, 0,
"x-expand", TRUE,
"x-fill", TRUE,
"y-expand", TRUE,
"y-fill", TRUE,
NULL);
icon = mx_icon_new ();
clutter_actor_set_name (icon, "penge-welcome-launcher-play-button");
mx_table_insert_actor_with_properties (MX_TABLE (inner_table),
icon,
0, 0,
"x-expand", TRUE,
"x-fill", FALSE,
"y-expand", TRUE,
"y-fill", FALSE,
NULL);
mx_table_insert_actor_with_properties (MX_TABLE (tile),
launcher,
1, 0,
"x-expand", FALSE,
"x-fill", FALSE,
"y-expand", FALSE,
"y-fill", FALSE,
"x-align", MX_ALIGN_START,
NULL);
g_signal_connect (launcher,
"clicked",
(GCallback)_welcome_launcher_clicked_cb,
NULL);
}
*/
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterColor stage_color = { 0x00, 0x00, 0x00, 0xff };
ClutterActor *label;
int w, h;
int row, col;
float scale = 1.0f;
g_setenv ("CLUTTER_VBLANK", "none", FALSE);
g_setenv ("CLUTTER_DEFAULT_FPS", "1000", FALSE);
clutter_init (&argc, &argv);
if (argc != 3)
{
g_printerr ("Usage test-text-perf FONT_SIZE N_CHARS\n");
exit (1);
}
font_size = atoi (argv[1]);
n_chars = atoi (argv[2]);
g_print ("Monospace %dpx, string length = %d\n", font_size, n_chars);
stage = clutter_stage_get_default ();
clutter_actor_set_size (stage, STAGE_WIDTH, STAGE_HEIGHT);
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
g_signal_connect (stage, "paint", G_CALLBACK (on_paint), NULL);
label = create_label ();
w = clutter_actor_get_width (label);
h = clutter_actor_get_height (label);
/* If the label is too big to fit on the stage then scale it so that
it will fit */
if (w > STAGE_WIDTH || h > STAGE_HEIGHT)
{
float x_scale = STAGE_WIDTH / (float) w;
float y_scale = STAGE_HEIGHT / (float) h;
if (x_scale < y_scale)
{
scale = x_scale;
cols = 1;
rows = STAGE_HEIGHT / (h * scale);
}
else
{
scale = y_scale;
cols = STAGE_WIDTH / (w * scale);
rows = 1;
}
g_print ("Text scaled by %f to fit on the stage\n", scale);
}
else
{
cols = STAGE_WIDTH / w;
rows = STAGE_HEIGHT / h;
}
clutter_actor_destroy (label);
for (row=0; row<rows; row++)
for (col=0; col<cols; col++)
{
label = create_label();
clutter_actor_set_scale (label, scale, scale);
clutter_actor_set_position (label, w * col * scale, h * row * scale);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), label);
}
clutter_actor_show_all (stage);
g_idle_add (queue_redraw, stage);
clutter_main ();
return 0;
}
static gboolean
on_timeout (State *state)
{
int test_num = 0;
int y, x;
ClutterActor *over_actor = NULL;
for (test_num = 0; test_num < 3; test_num++)
{
if (test_num == 0)
{
if (g_test_verbose ())
g_print ("No covering actor:\n");
}
if (test_num == 1)
{
static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff };
/* Create an actor that covers the whole stage but that
isn't visible so it shouldn't affect the picking */
over_actor = clutter_rectangle_new_with_color (&red);
clutter_actor_set_size (over_actor, STAGE_WIDTH, STAGE_HEIGHT);
clutter_container_add (CLUTTER_CONTAINER (state->stage),
over_actor, NULL);
clutter_actor_hide (over_actor);
if (g_test_verbose ())
g_print ("Invisible covering actor:\n");
}
else if (test_num == 2)
{
/* Make the actor visible but set a clip so that only some
of the actors are accessible */
clutter_actor_show (over_actor);
clutter_actor_set_clip (over_actor,
state->actor_width * 2,
state->actor_height * 2,
state->actor_width * (ACTORS_X - 4),
state->actor_height * (ACTORS_Y - 4));
if (g_test_verbose ())
g_print ("Clipped covering actor:\n");
}
for (y = 0; y < ACTORS_Y; y++)
for (x = 0; x < ACTORS_X; x++)
{
gboolean pass = FALSE;
guint32 gid;
ClutterActor *actor
= clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage),
CLUTTER_PICK_ALL,
x * state->actor_width
+ state->actor_width / 2,
y * state->actor_height
+ state->actor_height / 2);
if (g_test_verbose ())
g_print ("% 3i,% 3i / % 4i -> ",
x, y, (int) state->gids[y * ACTORS_X + x]);
if (actor == NULL)
{
if (g_test_verbose ())
g_print ("NULL: FAIL\n");
}
else if (actor == over_actor)
{
if (test_num == 2
&& x >= 2 && x < ACTORS_X - 2
&& y >= 2 && y < ACTORS_Y - 2)
pass = TRUE;
if (g_test_verbose ())
g_print ("over_actor: %s\n", pass ? "pass" : "FAIL");
}
else
{
gid = clutter_actor_get_gid (actor);
if (gid == state->gids[y * ACTORS_X + x]
&& (test_num != 2
|| x < 2 || x >= ACTORS_X - 2
|| y < 2 || y >= ACTORS_Y - 2))
pass = TRUE;
if (g_test_verbose ())
g_print ("% 10i: %s\n", gid, pass ? "pass" : "FAIL");
}
if (!pass)
state->pass = FALSE;
}
}
clutter_main_quit ();
return FALSE;
}
G_MODULE_EXPORT int
test_snap_constraint_main (int argc,
char *argv[])
{
ClutterActor *stage, *layer_a, *layer_b, *layer_c;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
/* the main container */
stage = clutter_stage_new ();
clutter_actor_set_name (stage, "stage");
clutter_stage_set_title (CLUTTER_STAGE (stage), "Snap Constraint");
clutter_stage_set_color (CLUTTER_STAGE (stage), CLUTTER_COLOR_Aluminium1);
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* first layer, with a fixed (100, 25) size */
layer_a = clutter_rectangle_new_with_color (CLUTTER_COLOR_ScarletRed);
clutter_actor_set_name (layer_a, "layerA");
clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_a);
clutter_actor_set_size (layer_a, 100.0, 25.0);
/* the first layer is anchored to the middle of the stage */
clutter_actor_add_constraint (layer_a, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));
clutter_actor_add_constraint (layer_a, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5));
/* second layer, with no implicit size */
layer_b = clutter_rectangle_new_with_color (CLUTTER_COLOR_DarkButter);
clutter_actor_set_name (layer_b, "layerB");
clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_b);
/* the second layer tracks the X coordinate and the width of
* the first layer
*/
clutter_actor_add_constraint (layer_b, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_X, 0.0));
clutter_actor_add_constraint (layer_b, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_WIDTH, 0.0));
/* the second layer is snapped between the bottom edge of
* the first layer, and the bottom edge of the stage; a
* spacing of 10 pixels in each direction is added for padding
*/
clutter_actor_add_constraint (layer_b,
clutter_snap_constraint_new (layer_a,
CLUTTER_SNAP_EDGE_TOP,
CLUTTER_SNAP_EDGE_BOTTOM,
10.0));
clutter_actor_add_constraint (layer_b,
clutter_snap_constraint_new (stage,
CLUTTER_SNAP_EDGE_BOTTOM,
CLUTTER_SNAP_EDGE_BOTTOM,
-10.0));
/* the third layer, with no implicit size */
layer_c = clutter_rectangle_new_with_color (CLUTTER_COLOR_LightChameleon);
clutter_actor_set_name (layer_c, "layerC");
clutter_container_add_actor (CLUTTER_CONTAINER (stage), layer_c);
/* as for the second layer, the third layer tracks the X
* coordinate and width of the first layer
*/
clutter_actor_add_constraint (layer_c, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_X, 0.0));
clutter_actor_add_constraint (layer_c, clutter_bind_constraint_new (layer_a, CLUTTER_BIND_WIDTH, 0.0));
/* the third layer is snapped between the top edge of the stage
* and the top edge of the first layer; again, a spacing of
* 10 pixels in each direction is added for padding
*/
clutter_actor_add_constraint (layer_c,
clutter_snap_constraint_new (layer_a,
CLUTTER_SNAP_EDGE_BOTTOM,
CLUTTER_SNAP_EDGE_TOP,
-10.0));
clutter_actor_add_constraint (layer_c,
clutter_snap_constraint_new (stage,
CLUTTER_SNAP_EDGE_TOP,
CLUTTER_SNAP_EDGE_TOP,
10.0));
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
int
main (int argc,
char *argv[])
{
ClutterActor *stage;
ClutterActor *texture;
gchar *image_path;
GError *error = NULL;
if (argc < 2)
{
g_print ("Usage: %s <path to image file>\n", argv[0]);
exit (EXIT_FAILURE);
}
image_path = argv[1];
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_actor_set_size (stage, STAGE_SIDE, STAGE_SIDE);
clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
texture = clutter_texture_new ();
clutter_actor_set_reactive (texture, TRUE);
clutter_actor_set_width (texture, STAGE_SIDE);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);
clutter_actor_add_action (texture, clutter_drag_action_new ());
g_object_set (G_OBJECT (texture),
"scale-gravity", CLUTTER_GRAVITY_NORTH_WEST,
NULL);
clutter_texture_set_from_file (CLUTTER_TEXTURE (texture), image_path, &error);
if (error != NULL)
{
g_warning ("Error loading %s\n%s", image_path, error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
clutter_actor_set_y (texture, (STAGE_SIDE - clutter_actor_get_height (texture)) * 0.5);
g_signal_connect (texture,
"button-release-event",
G_CALLBACK (clicked_cb),
NULL);
g_signal_connect_swapped (stage,
"key-press-event",
G_CALLBACK (key_press_cb),
texture);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), texture);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
static gint *
st_table_calculate_col_widths (StTable *table,
gint for_width)
{
gint total_min_width, i;
StTablePrivate *priv = table->priv;
gboolean *is_expand_col;
gint extra_col_width, n_expanded_cols = 0, expanded_cols = 0;
gint *pref_widths, *min_widths;
ClutterActor *child;
g_array_set_size (priv->is_expand_col, 0);
g_array_set_size (priv->is_expand_col, priv->n_cols);
is_expand_col = (gboolean *) priv->is_expand_col->data;
g_array_set_size (priv->pref_widths, 0);
g_array_set_size (priv->pref_widths, priv->n_cols);
pref_widths = (gint *) priv->pref_widths->data;
g_array_set_size (priv->min_widths, 0);
g_array_set_size (priv->min_widths, priv->n_cols);
min_widths = (gint *) priv->min_widths->data;
for (child = clutter_actor_get_first_child (CLUTTER_ACTOR (table));
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint col;
gfloat w_min, w_pref;
gboolean x_expand;
StTableChild *meta;
gint col_span;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
x_expand = meta->x_expand;
col_span = meta->col_span;
if (x_expand)
is_expand_col[col] = TRUE;
_st_actor_get_preferred_width (child, -1, meta->y_fill, &w_min, &w_pref);
if (col_span == 1 && w_pref > pref_widths[col])
{
pref_widths[col] = w_pref;
}
if (col_span == 1 && w_min > min_widths[col])
{
min_widths[col] = w_min;
}
}
total_min_width = priv->col_spacing * (priv->n_cols - 1);
for (i = 0; i < priv->n_cols; i++)
total_min_width += pref_widths[i];
/* calculate the remaining space and distribute it evenly onto all rows/cols
* with the x/y expand property set. */
for (i = 0; i < priv->n_cols; i++)
if (is_expand_col[i])
{
expanded_cols += pref_widths[i];
n_expanded_cols++;
}
/* for_width - total_min_width */
extra_col_width = for_width - total_min_width;
if (extra_col_width)
for (i = 0; i < priv->n_cols; i++)
if (is_expand_col[i])
{
if (extra_col_width < 0)
{
pref_widths[i] =
MAX (min_widths[i],
pref_widths[i]
+ (extra_col_width * (pref_widths[i] / (float) expanded_cols)));
/* if we reached the minimum width for this column, we need to
* stop counting it as expanded */
if (pref_widths[i] == min_widths[i])
{
/* restart calculations :-( */
expanded_cols -= pref_widths[i];
is_expand_col[i] = 0;
n_expanded_cols--;
i = -1;
}
}
else
pref_widths[i] += extra_col_width / n_expanded_cols;
}
return pref_widths;
}
static void
on_new_kinect_device (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
ClutterActor *stage, *instructions;
GError *error = NULL;
gint width = 640;
gint height = 480;
kinect = gfreenect_device_new_finish (res, &error);
if (kinect == NULL)
{
g_debug ("Failed to created kinect device: %s", error->message);
g_error_free (error);
clutter_main_quit ();
return;
}
g_debug ("Kinect device created!");
stage = clutter_stage_get_default ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Kinect Test");
clutter_actor_set_size (stage, width * 2, height + 200);
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
g_signal_connect (stage, "destroy", G_CALLBACK (on_destroy), kinect);
g_signal_connect (stage,
"key-release-event",
G_CALLBACK (on_key_release),
kinect);
depth_tex = clutter_cairo_texture_new (width, height);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), depth_tex);
video_tex = clutter_cairo_texture_new (width, height);
clutter_actor_set_position (video_tex, width, 0.0);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), video_tex);
info_text = clutter_text_new ();
set_info_text ();
clutter_actor_set_position (info_text, 50, height + 20);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), info_text);
instructions = create_instructions ();
clutter_actor_set_position (instructions, 50, height + 70);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), instructions);
clutter_actor_show_all (stage);
skeleton = SKELTRACK_SKELETON (skeltrack_skeleton_new ());
g_signal_connect (kinect,
"depth-frame",
G_CALLBACK (on_depth_frame),
NULL);
g_signal_connect (kinect,
"video-frame",
G_CALLBACK (on_video_frame),
NULL);
g_signal_connect (depth_tex,
"draw",
G_CALLBACK (on_texture_draw),
NULL);
gfreenect_device_set_tilt_angle (kinect, 0, NULL, NULL, NULL);
gfreenect_device_start_depth_stream (kinect,
GFREENECT_DEPTH_FORMAT_MM,
NULL);
gfreenect_device_start_video_stream (kinect,
GFREENECT_RESOLUTION_MEDIUM,
GFREENECT_VIDEO_FORMAT_RGB, NULL);
}
static void
st_table_preferred_allocate (ClutterActor *self,
const ClutterActorBox *content_box,
gboolean flags)
{
gint row_spacing, col_spacing;
gint i;
gint *col_widths, *row_heights;
StTable *table;
StTablePrivate *priv;
gboolean ltr;
ClutterActor *child;
table = ST_TABLE (self);
priv = ST_TABLE (self)->priv;
col_spacing = (priv->col_spacing);
row_spacing = (priv->row_spacing);
col_widths =
st_table_calculate_col_widths (table,
(int) (content_box->x2 - content_box->x1));
row_heights =
st_table_calculate_row_heights (table,
(int) (content_box->y2 - content_box->y1),
col_widths);
ltr = (clutter_actor_get_text_direction (self) == CLUTTER_TEXT_DIRECTION_LTR);
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, row_span, col_span;
gint col_width, row_height;
StTableChild *meta;
ClutterActorBox childbox;
gint child_x, child_y;
gdouble x_align_f, y_align_f;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
col = meta->col;
row = meta->row;
row_span = meta->row_span;
col_span = meta->col_span;
_st_get_align_factors (meta->x_align, meta->y_align,
&x_align_f, &y_align_f);
/* initialise the width and height */
col_width = col_widths[col];
row_height = row_heights[row];
/* Add the widths of the spanned columns:
*
* First check that we have a non-zero span. Then we loop over each of
* the columns that we're spanning but we stop short if we go past the
* number of columns in the table. This is necessary to avoid accessing
* uninitialised memory. We add the spacing in here too since we only
* want to add as much spacing as times we successfully span.
*/
if (col + col_span > priv->n_cols)
g_warning ("StTable: col-span exceeds number of columns");
#if 0
if (row + row_span > priv->n_rows)
g_warning ("StTable: row-span exceeds number of rows");
#endif
if (col_span > 1)
{
for (i = col + 1; i < col + col_span && i < priv->n_cols; i++)
{
col_width += col_widths[i];
col_width += col_spacing;
}
}
/* add the height of the spanned rows */
if (row_span > 1)
{
for (i = row + 1; i < row + row_span && i < priv->n_rows; i++)
{
row_height += row_heights[i];
row_height += row_spacing;
}
}
/* calculate child x */
if (ltr)
{
child_x = (int) content_box->x1
+ col_spacing * col;
for (i = 0; i < col; i++)
child_x += col_widths[i];
}
else
{
child_x = (int) content_box->x2
- col_spacing * col;
for (i = 0; i < col; i++)
child_x -= col_widths[i];
}
/* calculate child y */
child_y = (int) content_box->y1
+ row_spacing * row;
for (i = 0; i < row; i++)
child_y += row_heights[i];
/* set up childbox */
if (ltr)
{
childbox.x1 = (float) child_x;
childbox.x2 = (float) MAX (0, child_x + col_width);
}
else
{
childbox.x2 = (float) child_x;
childbox.x1 = (float) MAX (0, child_x - col_width);
}
childbox.y1 = (float) child_y;
childbox.y2 = (float) MAX (0, child_y + row_height);
clutter_actor_allocate_align_fill (child, &childbox,
x_align_f, y_align_f,
meta->x_fill, meta->y_fill,
flags);
}
}
static gboolean
actor_manipulator_press (ClutterActor *stage,
ClutterEvent *event,
gpointer data)
{
ClutterActor *actor;
actor = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (stage),
CLUTTER_PICK_ALL,
event->button.x,
event->button.y);
if (actor == stage ||
CLUTTER_IS_GROUP (actor))
{
if (event->button.button == 3)
{
popup_nuke (stage, event->button.x, event->button.y);
popup_add ("+rectangle", "bar", G_CALLBACK (
action_add_rectangle), scene_get_group ());
popup_add ("+circle", "bar", G_CALLBACK (
action_add_circle), scene_get_group ());
popup_add ("+triangle", "bar", G_CALLBACK (
action_add_triangle), scene_get_group ());
popup_add ("+text", "bar", G_CALLBACK (
action_add_text), scene_get_group ());
popup_add ("+image", "bar", G_CALLBACK (
action_add_image), scene_get_group ());
#if 0
popup_add ("+block-tree", "bar", G_CALLBACK (
action_add_block_tree), scene_get_group ());
#endif
popup_add ("zero gravity", "bar", G_CALLBACK (
action_zero_gravity), scene_get_group ());
}
return TRUE;
}
if (actor == NULL)
{
return FALSE;
}
if (event->button.button == 3)
{
popup_nuke (stage, event->button.x, event->button.y);
popup_add ("remove", "bar", G_CALLBACK (action_remove), actor);
popup_add ("set linear velocity", "bar", G_CALLBACK (action_set_linear_velocity), actor);
popup_add ("set dynamic", "bar", G_CALLBACK (action_set_dynamic), actor);
popup_add ("set static", "bar", G_CALLBACK (action_set_static), actor);
popup_add_slider ("opacity", "hm", 0.0, 255.0,
clutter_actor_get_opacity (actor) * 1.0,
G_CALLBACK (set_opacity), actor);
popup_add_slider ("rotation", "hm", 0.0, 360.0,
clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS, NULL,
NULL, NULL),
G_CALLBACK (set_rotation), actor);
popup_add ("ok", "bar", NULL, NULL);
return TRUE;
}
if (!should_be_manipulated (actor))
return FALSE;
manipulated_actor = actor;
clutter_actor_get_position (actor, &orig_x, &orig_y);
orig_rotation = clutter_actor_get_rotation (actor, CLUTTER_Z_AXIS, NULL,
NULL,
NULL);
start_x = (event->button.x);
start_y = (event->button.y);
clutter_actor_transform_stage_point (
clutter_actor_get_parent (manipulated_actor),
start_x, start_y,
&start_x, &start_y);
mode = Direct;
#ifdef BOX2D_MANIPULATION
/* Use Box2D manipulation if the actor is dynamic, and the physics
* engine is running
*/
if (CLUTTER_IS_BOX2D (scene_get_group ()) &&
clutter_box2d_get_simulating (CLUTTER_BOX2D (scene_get_group ())))
{
ClutterBox2D *box2d = CLUTTER_BOX2D (scene_get_group ());
/*ClutterVertex target = { start_x, start_y };*/
gint type;
clutter_container_child_get (CLUTTER_CONTAINER (box2d),
manipulated_actor, "mode", &type, NULL);
if (type == CLUTTER_BOX2D_DYNAMIC)
{
#if 0
mouse_joint = clutter_box2d_add_mouse_joint (CLUTTER_BOX2D (
scene_get_group ()),
manipulated_actor,
&target);
#endif
mode = None; /*Box2D;*/
manipulated_actor = NULL;
return FALSE;
}
}
#endif
clutter_set_motion_events_enabled (FALSE);
return TRUE;
}
static void
st_table_get_preferred_height (ClutterActor *self,
gfloat for_width,
gfloat *min_height_p,
gfloat *natural_height_p)
{
gint *min_heights, *pref_heights;
gfloat total_min_height, total_pref_height;
StTablePrivate *priv = ST_TABLE (self)->priv;
StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (self));
gint i;
gint *min_widths;
ClutterActor *child;
/* We only support height-for-width allocation. So if we are called
* width-for-height, calculate heights based on our natural width
*/
if (for_width < 0)
{
float natural_width;
clutter_actor_get_preferred_width (self, -1, NULL, &natural_width);
for_width = natural_width;
}
if (priv->n_rows < 1)
{
*min_height_p = 0;
*natural_height_p = 0;
return;
}
st_theme_node_adjust_for_width (theme_node, &for_width);
/* Setting size to zero and then what we want it to be causes a clear if
* clear flag is set (which it should be.)
*/
g_array_set_size (priv->min_heights, 0);
g_array_set_size (priv->pref_heights, 0);
g_array_set_size (priv->min_heights, priv->n_rows);
g_array_set_size (priv->pref_heights, priv->n_rows);
/* use min_widths to help allocation of height-for-width widgets */
min_widths = st_table_calculate_col_widths (ST_TABLE (self), for_width);
min_heights = (gint *) priv->min_heights->data;
pref_heights = (gint *) priv->pref_heights->data;
/* calculate minimum row heights */
for (child = clutter_actor_get_first_child (self);
child != NULL;
child = clutter_actor_get_next_sibling (child))
{
gint row, col, col_span, cell_width, row_span;
gfloat min, pref;
StTableChild *meta;
meta = (StTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (self), child);
if (!meta->allocate_hidden && !CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
/* get child properties */
row = meta->row;
col = meta->col;
col_span = meta->col_span;
row_span = meta->row_span;
cell_width = 0;
for (i = 0; i < col_span && col + i < priv->n_cols; i++)
cell_width += min_widths[col + i];
_st_actor_get_preferred_height (child, (float) cell_width, meta->x_fill,
&min, &pref);
if (row_span == 1 && min > min_heights[row])
min_heights[row] = min;
if (row_span == 1 && pref > pref_heights[row])
pref_heights[row] = pref;
}
/* start off with row spacing */
total_min_height = (priv->n_rows - 1) * (float) (priv->row_spacing);
total_pref_height = total_min_height;
for (i = 0; i < priv->n_rows; i++)
{
total_min_height += min_heights[i];
total_pref_height += pref_heights[i];
}
if (min_height_p)
*min_height_p = total_min_height;
if (natural_height_p)
*natural_height_p = total_pref_height;
st_theme_node_adjust_preferred_height (theme_node, min_height_p, natural_height_p);
}
static int mp_constructor(TPMediaPlayer * mp)
{
static int init=0;
if (!init)
{
init=1;
gst_init(NULL,NULL);
}
ClutterActor * video_texture=clutter_gst_video_texture_new();
if (!video_texture)
{
g_warning("FAILED TO CREATE CLUTTER GST VIDEO TEXTURE");
return TP_MEDIAPLAYER_ERROR_NO_MEDIAPLAYER;
}
// We own it
g_object_ref_sink(G_OBJECT(video_texture));
// Get the stage, size the video texture and add it to the stage
clutter_actor_hide(video_texture);
ClutterActor * stage=clutter_stage_get_default();
gfloat width,height;
clutter_actor_get_size(stage,&width,&height);
clutter_actor_set_size(video_texture,width,height);
clutter_actor_set_position(video_texture,0,0);
clutter_container_add_actor(CLUTTER_CONTAINER(stage),video_texture);
clutter_actor_lower_bottom(video_texture);
g_signal_connect( stage , "notify::allocation" , ( GCallback ) stage_allocation_notify , video_texture );
// Connect signals
g_signal_connect(video_texture,"eos",G_CALLBACK(mp_end_of_stream),mp);
g_signal_connect(video_texture,"error",G_CALLBACK(mp_error),mp);
// We use gmalloc0 to zero out the whole structure
UserData * user_data=(UserData*) g_malloc0(sizeof(UserData));
user_data->vt=video_texture;
mp->user_data=user_data;
mp->destroy=mp_destroy;
mp->load=mp_load;
mp->reset=mp_reset;
mp->play=mp_play;
mp->seek=mp_seek;
mp->pause=mp_pause;
mp->set_playback_rate=mp_set_playback_rate;
mp->get_position=mp_get_position;
mp->get_duration=mp_get_duration;
mp->get_buffered_duration=mp_get_buffered_duration;
mp->get_video_size=mp_get_video_size;
mp->get_viewport_geometry=mp_get_viewport_geometry;
mp->set_viewport_geometry=mp_set_viewport_geometry;
mp->get_media_type=mp_get_media_type;
mp->get_audio_volume=mp_get_audio_volume;
mp->set_audio_volume=mp_set_audio_volume;
mp->get_audio_mute=mp_get_audio_mute;
mp->set_audio_mute=mp_set_audio_mute;
mp->play_sound=mp_play_sound;
mp->get_viewport_texture=mp_get_viewport_texture;
return 0;
}
static void
mx_stack_allocate (ClutterActor *actor,
const ClutterActorBox *box,
ClutterAllocationFlags flags)
{
GList *c;
ClutterActorBox avail_space;
MxStackPrivate *priv = MX_STACK (actor)->priv;
CLUTTER_ACTOR_CLASS (mx_stack_parent_class)->allocate (actor, box, flags);
mx_widget_get_available_area (MX_WIDGET (actor), box, &avail_space);
memcpy (&priv->allocation, box, sizeof (priv->allocation));
for (c = priv->children; c; c = c->next)
{
gboolean x_fill, y_fill, fit, crop;
MxAlign x_align, y_align;
ClutterActor *child = c->data;
ClutterActorBox child_box = avail_space;
if (!CLUTTER_ACTOR_IS_VISIBLE (child))
continue;
clutter_container_child_get (CLUTTER_CONTAINER (actor),
child,
"x-fill", &x_fill,
"y-fill", &y_fill,
"x-align", &x_align,
"y-align", &y_align,
"fit", &fit,
"crop", &crop,
NULL);
/* when "crop" is set, fit and fill properties are ignored */
if (crop)
{
gfloat available_height, available_width;
gfloat natural_width, natural_height;
gfloat ratio_width, ratio_height, ratio_child;
available_width = avail_space.x2 - avail_space.x1;
available_height = avail_space.y2 - avail_space.y1;
clutter_actor_get_preferred_size (child,
NULL, NULL,
&natural_width,
&natural_height);
ratio_child = natural_width / natural_height;
ratio_width = available_width / natural_width;
ratio_height = available_height / natural_height;
if (ratio_width > ratio_height)
{
natural_width = available_width;
natural_height = natural_width / ratio_child;
}
else
{
natural_height = available_height;
natural_width = ratio_child * natural_height;
}
child_box.x1 = (available_width - natural_width) / 2;
child_box.y1 = (available_height - natural_height) / 2;
child_box.x2 = natural_width;
child_box.y2 = natural_height;
clutter_actor_allocate (child, &child_box, flags);
continue;
}
/* when "fit" is set, fill properties are ignored */
if (fit)
{
gfloat available_height, available_width, width, height;
gfloat min_width, natural_width, min_height, natural_height;
ClutterRequestMode request_mode;
available_height = avail_space.y2 - avail_space.y1;
available_width = avail_space.x2 - avail_space.x1;
request_mode = clutter_actor_get_request_mode (child);
if (request_mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
{
clutter_actor_get_preferred_width (child, available_height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
clutter_actor_get_preferred_height (child, width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
}
else
{
clutter_actor_get_preferred_height (child, available_width,
&min_height,
&natural_height);
height = CLAMP (natural_height, min_height, available_height);
clutter_actor_get_preferred_width (child, height,
&min_width,
&natural_width);
width = CLAMP (natural_width, min_width, available_width);
}
child_box.x1 = 0;
child_box.y1 = 0;
switch (x_align)
{
case MX_ALIGN_START:
break;
case MX_ALIGN_MIDDLE:
child_box.x1 += (gint)(available_width / 2 - width / 2);
break;
case MX_ALIGN_END:
child_box.x1 = avail_space.x2 - width;
break;
}
switch (y_align)
{
case MX_ALIGN_START:
break;
case MX_ALIGN_MIDDLE:
child_box.y1 += (gint)(available_height / 2 - height / 2);
break;
case MX_ALIGN_END:
child_box.y1 = avail_space.y2 - height;
break;
}
child_box.x2 = child_box.x1 + width;
child_box.y2 = child_box.y1 + height;
clutter_actor_allocate (child, &child_box, flags);
continue;
}
/* Adjust the available space when not filling, otherwise
* actors that support width-for-height or height-for-width
* allocation won't shrink correctly.
*/
if (!x_fill)
{
gfloat width;
clutter_actor_get_preferred_width (child, -1, NULL, &width);
switch (x_align)
{
case MX_ALIGN_START:
break;
case MX_ALIGN_MIDDLE:
child_box.x1 += (gint)((avail_space.x2 - avail_space.x1) / 2 -
width / 2);
break;
case MX_ALIGN_END:
child_box.x1 = avail_space.x2 - width;
break;
}
child_box.x2 = child_box.x1 + width;
if (child_box.x2 > avail_space.x2)
child_box.x2 = avail_space.x2;
if (child_box.x1 < avail_space.x1)
child_box.x1 = avail_space.x1;
}
if (!y_fill)
{
gfloat height;
clutter_actor_get_preferred_height (child, -1, NULL, &height);
switch (y_align)
{
case MX_ALIGN_START:
break;
case MX_ALIGN_MIDDLE:
child_box.y1 += (gint)((avail_space.y2 - avail_space.y1) / 2 -
height / 2);
break;
case MX_ALIGN_END:
child_box.y1 = avail_space.y2 - height;
break;
}
child_box.y2 = child_box.y1 + height;
if (child_box.y2 > avail_space.y2)
child_box.y2 = avail_space.y2;
if (child_box.y1 < avail_space.y1)
child_box.y1 = avail_space.y1;
}
mx_allocate_align_fill (child,
&child_box,
x_align,
y_align,
x_fill,
y_fill);
clutter_actor_allocate (child, &child_box, flags);
}
}
static gboolean bar_pane_gps_create_markers_cb(gpointer data)
{
PaneGPSData *pgd = data;
gdouble latitude;
gdouble longitude;
GList *work;
ClutterActor *marker;
FileData *fd;
ClutterColor marker_colour = { MARKER_COLOUR };
GString *message;
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pgd->progress),
(gdouble)(pgd->selection_count - g_list_length(pgd->selection_list)) /
(gdouble)pgd->selection_count);
message = g_string_new("");
g_string_printf(message, "%i/%i", (pgd->selection_count - g_list_length(pgd->selection_list)),
pgd->selection_count);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pgd->progress), message->str);
g_string_free(message, TRUE);
work = pgd->selection_list;
while (work)
{
fd = work->data;
pgd->selection_list = g_list_remove(pgd->selection_list, work->data);
/* If the file has a parent, it must be a sidecar file. Do not process sidecar files
*/
if (fd != NULL && fd->parent == NULL)
{
latitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLatitude", 1000);
longitude = metadata_read_GPS_coord(fd, "Xmp.exif.GPSLongitude", 1000);
if ((latitude != 1000) && (longitude != 1000))
{
marker = champlain_marker_new_with_text("i","courier 5", &marker_colour, &marker_colour);
champlain_base_marker_set_position(CHAMPLAIN_BASE_MARKER(marker), latitude, longitude);
clutter_container_add(CLUTTER_CONTAINER(pgd->icon_layer), marker, NULL);
clutter_actor_set_reactive(marker, TRUE);
g_signal_connect(G_OBJECT(marker), "button_release_event",
G_CALLBACK(bar_pane_gps_marker_keypress_cb), pgd);
g_object_set_data(G_OBJECT(marker), "file_fd", fd);
g_ptr_array_add(pgd->marker_list, marker);
if (pgd->centre_map_checked)
{
g_ptr_array_add(pgd->marker_list, NULL);
champlain_view_ensure_markers_visible(CHAMPLAIN_VIEW(pgd->gps_view),
(void *)pgd->marker_list->pdata, FALSE);
g_ptr_array_remove(pgd->marker_list, NULL);
}
}
}
return TRUE;
}
if (pgd->marker_list->len >= 1)
{
g_ptr_array_add(pgd->marker_list, NULL);
if (pgd->centre_map_checked)
{
champlain_view_ensure_markers_visible(CHAMPLAIN_VIEW(pgd->gps_view), (void *)pgd->marker_list->pdata, FALSE);
}
}
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(pgd->progress), 0);
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(pgd->progress), NULL);
g_list_free(pgd->selection_list);
g_ptr_array_free(pgd->marker_list, TRUE);
pgd->create_markers_id = 0;
return FALSE;
}
