void clarity_cover_set_album_item (ClarityCover *self, AlbumItem *item) {
g_return_if_fail(CLARITY_IS_COVER(self));
ClarityCoverPrivate *priv = CLARITY_COVER_GET_PRIVATE (self);
g_return_if_fail(priv);
GError *error = NULL;
gint y_offset;
if (!priv->texture) {
priv->texture = gtk_clutter_texture_new();
clutter_container_add_actor(CLUTTER_CONTAINER(self), priv->texture);
}
// Set cover artwork
gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE(priv->texture), item->albumart, &error);
if (error) {
g_warning("%s", error->message);
g_error_free(error);
return;
}
// Add reflection
if (! priv->reflection) {
y_offset = clutter_actor_get_height (priv->texture) + V_PADDING;
priv->reflection = clutter_clone_new (priv->texture);
clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_X, 0.0));
clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_Y, y_offset));
clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_WIDTH, 0.0));
clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_HEIGHT, 0.0));
g_signal_connect (priv->reflection,
"paint",
G_CALLBACK (_clone_paint_cb),
NULL);
clutter_container_add_actor(CLUTTER_CONTAINER(self), priv->reflection);
}
ClutterActorBox box;
gfloat w, h;
clutter_actor_get_allocation_box (priv->texture, &box);
clutter_actor_box_get_size (&box, &w, &h);
if( h > DEFAULT_IMG_SIZE) {
gfloat temp = w * DEFAULT_IMG_SIZE / h;
clutter_actor_set_size(priv->texture, temp, DEFAULT_IMG_SIZE);
}
// Add title / artist data
if (priv->title)
g_free(priv->title);
priv->title = g_strdup(item->albumname);
if (priv->artist)
g_free(priv->artist);
priv->artist = g_strdup(item->artist);
}
int
main (int argc, char **argv)
{
const ClutterColor grey = { 0x40, 0x40, 0x40, 0xff };
ClutterActor *stage, *info_bar;
ClutterConstraint *constraint;
MxApplication *app;
MxWindow *window;
mex_init (&argc, &argv);
app = mx_application_new (&argc, &argv, "mex-media-controls-test", 0);
mex_style_load_default ();
window = mx_application_create_window (app);
stage = (ClutterActor *)mx_window_get_clutter_stage (window);
clutter_stage_set_color (CLUTTER_STAGE (stage), &grey);
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
info_bar = mex_info_bar_get_default ();
constraint = clutter_bind_constraint_new (stage, CLUTTER_BIND_WIDTH, 0.0);
clutter_actor_add_constraint (info_bar, constraint);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), info_bar);
clutter_actor_set_size (stage, 1024, 768);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
static void
cheese_widget_init (CheeseWidget *widget)
{
CheeseWidgetPrivate *priv = CHEESE_WIDGET_GET_PRIVATE (widget);
GtkWidget *box;
ClutterActor *stage, *frame;
ClutterConstraint *constraint;
ClutterColor black = { 0x00, 0x00, 0x00, 0xff };
priv->state = CHEESE_WIDGET_STATE_NONE;
priv->error = NULL;
/* XXX
* remove this line if you want to debug */
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (widget), FALSE);
gtk_notebook_set_show_border (GTK_NOTEBOOK (widget), FALSE);
/* Spinner page */
priv->spinner = gtk_spinner_new ();
box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), priv->spinner);
cheese_widget_spinner_invert (priv->spinner, box);
gtk_widget_show_all (box);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
box, gtk_label_new ("spinner"));
/* Webcam page */
priv->screen = gtk_clutter_embed_new ();
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (priv->screen));
clutter_stage_set_color (CLUTTER_STAGE (stage), &black);
frame = cheese_aspect_frame_new ();
priv->texture = clutter_texture_new ();
clutter_actor_set_size (priv->texture, 400, 300);
mx_bin_set_child (MX_BIN (frame), priv->texture);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), frame);
constraint = clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0.0);
clutter_actor_add_constraint_with_name (frame, "size", constraint);
gtk_widget_show (priv->screen);
clutter_actor_show (priv->texture);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
priv->screen, gtk_label_new ("webcam"));
/* Problem page */
priv->problem = gtk_drawing_area_new ();
gtk_widget_show (priv->problem);
gtk_notebook_append_page (GTK_NOTEBOOK (widget),
priv->problem,
gtk_label_new ("got problems"));
priv->settings = g_settings_new ("org.gnome.Cheese");
}
G_MODULE_EXPORT int
test_texture_material_main (int argc, char *argv[])
{
ClutterActor *stage, *box;
ClutterLayoutManager *manager;
int i;
g_thread_init (NULL);
clutter_threads_init ();
clutter_init (&argc, &argv);
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Texture Material");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
manager = clutter_flow_layout_new (CLUTTER_FLOW_HORIZONTAL);
box = clutter_box_new (manager);
clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_WIDTH, -25.0));
clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_HEIGHT, -25.0));
clutter_actor_set_position (box, 25.0, 25.0);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box);
for (i = 0; i < 48; i++)
{
ClutterActor *texture = clutter_texture_new ();
clutter_texture_set_load_data_async (CLUTTER_TEXTURE (texture), TRUE);
clutter_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);
clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
TESTS_DATADIR "/redhand.png",
NULL);
clutter_actor_set_width (texture, 96);
clutter_container_add_actor (CLUTTER_CONTAINER (box), texture);
}
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *texture;
GError *error = NULL;
ClutterActor *clone;
gfloat y_offset;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Reflection");
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
texture = clutter_texture_new ();
clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
"redhand.png",
&error);
clutter_actor_add_constraint (texture, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));
clutter_actor_add_constraint (texture, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.2));
y_offset = clutter_actor_get_height (texture) + V_PADDING;
clone = clutter_clone_new (texture);
clutter_actor_add_constraint (clone, clutter_bind_constraint_new (texture, CLUTTER_BIND_X, 0.0));
clutter_actor_add_constraint (clone, clutter_bind_constraint_new (texture, CLUTTER_BIND_Y, y_offset));
g_signal_connect (clone,
"paint",
G_CALLBACK (_clone_paint_cb),
NULL);
clutter_container_add (CLUTTER_CONTAINER (stage), texture, clone, NULL);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
static void
editor_toolbar_align (BjbEditorToolbar *self, GdkEvent *event)
{
gint x_alignment, y_alignment;
ClutterConstraint *constraint;
BjbEditorToolbarPrivate *priv = self->priv;
x_alignment = event->button.x + EDITOR_TOOLBAR_X_OFFSET;
y_alignment = event->button.y + EDITOR_TOOLBAR_Y_OFFSET;
if ( x_alignment < 0)
x_alignment = 0;
constraint = clutter_bind_constraint_new (priv->parent_actor,
CLUTTER_BIND_Y,
y_alignment);
clutter_actor_add_constraint (priv->actor, constraint);
constraint = clutter_bind_constraint_new (priv->parent_actor,
CLUTTER_BIND_X,
x_alignment);
clutter_actor_add_constraint (priv->actor, constraint);
}
static void
test_window (void)
{
GsdOsdDrawContext ctx;
ClutterActor *stage, *actor;
ClutterContent *canvas;
GtkWidgetPath *widget_path;
/* create a resizable stage */
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "OSD Test");
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
clutter_actor_set_background_color (stage, CLUTTER_COLOR_Red);
clutter_actor_set_size (stage, 300, 300);
clutter_actor_show (stage);
/* box canvas */
canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300);
actor = clutter_actor_new ();
clutter_actor_add_constraint (actor, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0));
clutter_actor_set_content (actor, canvas);
g_object_unref (canvas);
clutter_actor_add_child (stage, actor);
memset (&ctx, 0, sizeof(ctx));
widget_path = gtk_widget_path_new ();
gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW);
ctx.style = gtk_style_context_new ();
gtk_style_context_set_path (ctx.style, widget_path);
ctx.direction = clutter_get_default_text_direction ();
ctx.theme = gtk_icon_theme_get_default ();
g_signal_connect (canvas, "draw", G_CALLBACK (draw_box), &ctx);
clutter_content_invalidate (canvas);
g_signal_connect (stage, "destroy", G_CALLBACK (gtk_main_quit), NULL);
}
static ClutterActor *
create_scroll_actor (ClutterActor *stage)
{
ClutterActor *scroll;
ClutterAction *pan_action;
/* our scrollable viewport */
scroll = clutter_actor_new ();
clutter_actor_set_name (scroll, "scroll");
clutter_actor_add_constraint (scroll, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0));
clutter_actor_add_constraint (scroll, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0));
clutter_actor_add_child (scroll, create_content_actor ());
pan_action = clutter_pan_action_new ();
clutter_pan_action_set_interpolate (CLUTTER_PAN_ACTION (pan_action), TRUE);
g_signal_connect (pan_action, "pan", G_CALLBACK (on_pan), NULL);
clutter_actor_add_action (scroll, pan_action);
clutter_actor_set_reactive (scroll, TRUE);
return scroll;
}
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, *box, *bg, *bg2, *inset, *labelContainer,
*contentContainer, *labelbg, *fixed, *upper, *lower, *lowerInner;
ClutterLayoutManager *layout, *labelContainer_l, *layoutFixed;
ClutterTimeline *timeline;
ClutterContent *canvas, *canvas1;
ClutterColor color_with_trans = {0,0,0,0};
clutter_x11_set_use_argb_visual (TRUE);
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return (1);
/* prepare the stage */
stage = clutter_stage_new ();
clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);
clutter_stage_set_color (CLUTTER_STAGE (stage), &color_with_trans);
clutter_stage_set_title (CLUTTER_STAGE (stage), "IPLocation Database");
clutter_actor_set_background_color (stage, CLUTTER_COLOR_WHITE);
clutter_actor_set_size (stage, 648, 246);
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
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_actor_new ();
clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0.0));
clutter_actor_set_background_color (box, CLUTTER_COLOR_WHITE);
clutter_actor_set_layout_manager (box, layout);
clutter_actor_add_constraint (box, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 1));
clutter_actor_set_name (box, "box");
clutter_actor_add_child (stage, box);
bg = clutter_actor_new ();
//clutter_actor_set_background_color (bg, clutter_color_new (50, 50, 50, 255));
clutter_actor_set_name (bg, "background");
clutter_actor_set_reactive (bg, TRUE);
//clutter_actor_set_x_expand (bg, TRUE);
//clutter_actor_set_y_expand (bg, TRUE);
clutter_actor_set_x_align (bg, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_set_y_align (bg, CLUTTER_ACTOR_ALIGN_FILL);
canvas1 = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas1), 300, 300);
clutter_actor_set_content (bg, canvas1);
/*clutter_actor_set_content_scaling_filters (bg2,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);*/
g_object_unref (canvas1);
clutter_actor_add_child (box, bg);
bg2 = clutter_actor_new ();
//clutter_actor_set_background_color (bg2, clutter_color_new (0, 100, 100, 255*.5));
clutter_actor_set_name (bg2, "background");
clutter_actor_set_reactive (bg2, TRUE);
clutter_actor_set_size (bg2, 0, 0);
//clutter_actor_set_x_expand (bg2, TRUE);
//clutter_actor_set_y_expand (bg2, TRUE);
clutter_actor_set_x_align (bg2, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_set_y_align (bg2, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_set_clip_to_allocation(bg2, TRUE);
clutter_actor_add_child (box, bg2);
clutter_actor_set_layout_manager (bg2, clutter_box_layout_new ());
canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300);
clutter_actor_set_content (bg2, canvas);
/*clutter_actor_set_content_scaling_filters (bg2,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);*/
g_object_unref (canvas);
inset = clutter_actor_new ();
//clutter_actor_set_background_color (inset, clutter_color_new (255, 0, 0, 255));
clutter_actor_set_name (inset, "inset");
clutter_actor_set_reactive (inset, TRUE);
clutter_actor_set_margin_top (inset, 18);
clutter_actor_set_margin_right (inset, 18);
clutter_actor_set_margin_bottom (inset, 18);
clutter_actor_set_margin_left (inset, 48);
//clutter_actor_set_x_expand (inset, TRUE);
//clutter_actor_set_y_expand (inset, TRUE);
clutter_actor_set_x_align (inset, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_set_y_align (inset, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_set_clip_to_allocation(inset, TRUE);
clutter_actor_add_child (bg2, inset);
layout = clutter_box_layout_new ();
clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (layout),
TRUE);
clutter_box_layout_set_spacing (CLUTTER_BOX_LAYOUT (layout), 5);
clutter_actor_set_layout_manager (inset, layout);
labelContainer = clutter_actor_new ();
clutter_actor_set_size (labelContainer, 0, 35);
//clutter_actor_set_background_color (labelContainer, clutter_color_new (34, 134, 158, 255));
clutter_actor_set_name (labelContainer, "labelContainer");
clutter_actor_set_reactive (labelContainer, TRUE);
//clutter_actor_set_x_expand (labelContainer, TRUE);
//clutter_actor_set_y_expand (labelContainer, TRUE);
clutter_actor_add_child (inset, labelContainer);
labelContainer_l = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
clutter_actor_set_layout_manager (labelContainer, labelContainer_l);
labelbg = clutter_actor_new ();
clutter_actor_set_background_color (labelbg, clutter_color_new (34, 134, 158, 255));
clutter_actor_set_name (labelbg, "labelbg");
//clutter_actor_set_x_expand (labelbg, TRUE);
clutter_actor_set_size (labelbg, 0, 35);
clutter_actor_set_x_align (labelbg, CLUTTER_ACTOR_ALIGN_START);
clutter_actor_set_y_align (labelbg, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_add_child (labelContainer, labelbg);
contentContainer = clutter_actor_new ();
clutter_actor_set_size (contentContainer, 0, 0);
clutter_actor_set_background_color (contentContainer, clutter_color_new (0.290196*255, 0.427451*255, 0.462745*255, 255));
clutter_actor_set_name (contentContainer, "labelContainer");
//clutter_actor_set_x_expand (contentContainer, TRUE);
//clutter_actor_set_y_expand (contentContainer, TRUE);
clutter_actor_set_layout_manager (contentContainer, clutter_fixed_layout_new ());
clutter_actor_add_child (inset, contentContainer);
fixed = clutter_actor_new ();
clutter_actor_set_background_color (fixed, clutter_color_new (9, 53, 71, 255));
clutter_actor_set_name (fixed, "fixed");
clutter_actor_set_size (fixed, 582, 210-40);
clutter_actor_set_position (fixed, 582, 0);
layoutFixed = clutter_box_layout_new ();
clutter_box_layout_set_vertical (CLUTTER_BOX_LAYOUT (layoutFixed),
TRUE);
clutter_box_layout_set_spacing (CLUTTER_BOX_LAYOUT (layoutFixed), 8);
clutter_actor_set_layout_manager (fixed, layoutFixed);
clutter_actor_add_child (contentContainer, fixed);
//------------------------------------------------------------------------//
lower = clutter_actor_new ();
clutter_actor_set_size (lower, 0, 0);
clutter_actor_set_name (lower, "lower");
//clutter_actor_set_x_expand (lower, TRUE);
//clutter_actor_set_y_expand (lower, TRUE);
clutter_actor_set_margin_right (lower, 8);
clutter_actor_set_margin_top (lower, 8);
clutter_actor_set_margin_left (lower, 8);
clutter_actor_set_layout_manager (lower, clutter_fixed_layout_new ());
clutter_actor_set_clip_to_allocation(lower, TRUE);
clutter_actor_add_child (fixed, lower);
lowerInner = clutter_actor_new ();
clutter_actor_set_background_color (lowerInner, clutter_color_new (255, 255, 255, 30));
clutter_actor_set_name (lowerInner, "fixed");
clutter_actor_set_size (lowerInner, 566, 113);
clutter_actor_set_position (lowerInner, 566, 0);
clutter_actor_add_child (lower, lowerInner);
upper = clutter_actor_new ();
clutter_actor_set_size (upper, 0, 33);
clutter_actor_set_name (upper, "upper");
clutter_actor_set_x_expand (upper, TRUE);
//clutter_actor_set_y_expand (upper, TRUE);
clutter_actor_set_margin_bottom (upper, 8);
clutter_actor_set_margin_right (upper, 8);
clutter_actor_set_margin_left (upper, 8);
//clutter_actor_set_layout_manager (upper, clutter_fixed_layout_new ());
clutter_actor_add_child (fixed, upper);
timeline = clutter_timeline_new (57/24.*1000);
clutter_timeline_add_marker_at_time(timeline, "first", (40-35)/24.*1000);
clutter_timeline_add_marker_at_time(timeline, "second", (46-35)/24.*1000);
clutter_timeline_add_marker_at_time(timeline, "third", (51-35)/24.*1000);
clutter_timeline_add_marker_at_time(timeline, "fourth", (52-35)/24.*1000);
clutter_timeline_add_marker_at_time(timeline, "fifth", (58-35)/24.*1000);
g_signal_connect (timeline, "marker-reached::first", G_CALLBACK (plate1anim), bg);
g_signal_connect (timeline, "marker-reached::second", G_CALLBACK (plate2anim), bg2);
g_signal_connect (timeline, "marker-reached::third", G_CALLBACK (plate3anim), labelbg);
g_signal_connect (timeline, "marker-reached::fourth", G_CALLBACK (plate4anim), fixed);
g_signal_connect (timeline, "marker-reached::fifth", G_CALLBACK (plate5anim), lowerInner);
g_signal_connect (canvas1, "draw", G_CALLBACK (draw_1), NULL);
g_signal_connect (bg, "paint", G_CALLBACK (on_actor_resize), canvas);
g_signal_connect (canvas, "draw", G_CALLBACK (draw), NULL);
g_signal_connect (bg2, "paint", G_CALLBACK (on_actor_resize), canvas);
clutter_content_invalidate (canvas);
clutter_timeline_start (timeline);
clutter_main ();
return (EXIT_SUCCESS);
}
int
main (int argc, char **argv)
{
ClutterActor *stage;
ClutterActor *fader;
ClutterConstraint *constraint;
CoglHandle tex0, tex1;
GError *error = NULL;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
if (argc != 3)
{
g_print ("usage: %s <image1> <image2>\n",
argv[0]);
return 1;
}
tex0 = cogl_texture_new_from_file (argv[1],
COGL_TEXTURE_NO_SLICING |
COGL_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_ANY,
&error);
if (tex0 == COGL_INVALID_HANDLE)
{
g_print ("error opening %s: %s\n", argv[1], error->message);
g_clear_error (&error);
return 1;
}
tex1 = cogl_texture_new_from_file (argv[2],
COGL_TEXTURE_NO_SLICING |
COGL_TEXTURE_NO_ATLAS,
COGL_PIXEL_FORMAT_ANY,
&error);
if (tex1 == COGL_INVALID_HANDLE)
{
cogl_handle_unref (tex0);
g_print ("error opening %s: %s\n", argv[2], error->message);
g_clear_error (&error);
return 1;
}
fader = foo_fader_new ();
foo_fader_set_texture_0 (FOO_FADER (fader), tex0);
foo_fader_set_texture_1 (FOO_FADER (fader), tex1);
cogl_handle_unref (tex0);
cogl_handle_unref (tex1);
stage = clutter_stage_get_default ();
clutter_stage_set_fullscreen (CLUTTER_STAGE (stage), TRUE);
g_signal_connect (stage, "button-press-event",
G_CALLBACK (button_press_event_cb),
fader);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), fader);
constraint =
clutter_bind_constraint_new (stage,
CLUTTER_BIND_SIZE,
0.0f);
clutter_actor_add_constraint (fader, constraint);
/* massive hack --- nothing to see here! */
foo_fader_set_progress (FOO_FADER (fader), 0.00001f);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
static void
set_up_stage (CalibArea *calib_area, ClutterActor *stage)
{
ClutterPoint anchor;
ClutterColor color;
ClutterContent *success_content;
gfloat height;
gchar *markup;
calib_area->stage = stage;
calib_area->action_layer = clutter_actor_new ();
calib_area->clock = cc_clock_actor_new ();
calib_area->target = cc_target_actor_new ();
calib_area->text_title_holder = clutter_actor_new ();
calib_area->helper_text_title = clutter_text_new ();
calib_area->text_body_holder = clutter_actor_new ();
calib_area->helper_text_body = clutter_text_new ();
calib_area->error_text = clutter_text_new ();
calib_area->success_image = clutter_actor_new ();
clutter_stage_set_use_alpha (CLUTTER_STAGE (stage), TRUE);
clutter_actor_hide (calib_area->target);
/* bind the action layer's geometry to the stage's */
clutter_actor_add_constraint (calib_area->action_layer,
clutter_bind_constraint_new (stage,
CLUTTER_BIND_SIZE,
0));
clutter_actor_add_child (stage, calib_area->action_layer);
g_signal_connect (stage,
"allocation-changed",
G_CALLBACK (on_allocation_changed),
calib_area);
clutter_color_from_string (&color, "#000");
color.alpha = WINDOW_OPACITY * 255;
clutter_actor_set_background_color (stage, &color);
clutter_actor_add_child (calib_area->action_layer, calib_area->clock);
clutter_actor_add_constraint (calib_area->clock,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_BOTH,
0.5));
clutter_actor_add_child (calib_area->action_layer, calib_area->target);
/* set the helper text */
anchor.x = 0;
g_object_set (calib_area->text_title_holder, "pivot-point", &anchor, NULL);
clutter_actor_add_child (calib_area->action_layer,
calib_area->text_title_holder);
clutter_actor_add_child (calib_area->text_title_holder,
calib_area->helper_text_title);
height = clutter_actor_get_height (calib_area->clock);
clutter_actor_add_constraint (calib_area->text_title_holder,
clutter_bind_constraint_new (calib_area->clock,
CLUTTER_BIND_Y,
height * 1.5));
clutter_actor_add_constraint (calib_area->text_title_holder,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_X_AXIS,
.5));
clutter_text_set_line_alignment (CLUTTER_TEXT (calib_area->helper_text_title),
PANGO_ALIGN_CENTER);
color.red = COLOR_GRAY;
color.green = COLOR_GRAY;
color.blue = COLOR_GRAY;
color.alpha = 255;
markup = g_strdup_printf ("<big><b>%s</b></big>",
_(HELP_TEXT_TITLE));
clutter_text_set_markup (CLUTTER_TEXT (calib_area->helper_text_title), markup);
clutter_text_set_color (CLUTTER_TEXT (calib_area->helper_text_title), &color);
g_free (markup);
g_object_set (calib_area->text_body_holder, "pivot-point", &anchor, NULL);
clutter_actor_add_child (calib_area->action_layer,
calib_area->text_body_holder);
clutter_actor_add_child (calib_area->text_body_holder,
calib_area->helper_text_body);
height = clutter_actor_get_height (calib_area->helper_text_title);
clutter_actor_add_constraint (calib_area->text_body_holder,
clutter_bind_constraint_new (calib_area->text_title_holder,
CLUTTER_BIND_Y,
height * 1.2));
clutter_actor_add_constraint (calib_area->text_body_holder,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_X_AXIS,
.5));
clutter_text_set_line_alignment (CLUTTER_TEXT (calib_area->helper_text_body),
PANGO_ALIGN_CENTER);
markup = g_strdup_printf ("<span foreground=\"white\"><big>%s</big></span>",
_(HELP_TEXT_MAIN));
clutter_text_set_markup (CLUTTER_TEXT (calib_area->helper_text_body), markup);
g_free (markup);
/* set the error text */
g_object_set (calib_area->error_text, "pivot-point", &anchor, NULL);
clutter_actor_add_child (calib_area->action_layer, calib_area->error_text);
height = clutter_actor_get_height (calib_area->helper_text_body);
clutter_actor_add_constraint (calib_area->error_text,
clutter_bind_constraint_new (calib_area->text_title_holder,
CLUTTER_BIND_Y,
height * 3));
clutter_actor_add_constraint (calib_area->error_text,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_X_AXIS,
.5));
clutter_text_set_line_alignment (CLUTTER_TEXT (calib_area->error_text),
PANGO_ALIGN_CENTER);
markup = g_strdup_printf ("<span foreground=\"white\"><big>"
"<b>%s</b></big></span>",
ERROR_MESSAGE);
clutter_text_set_markup (CLUTTER_TEXT (calib_area->error_text), markup);
g_free (markup);
clutter_actor_hide (calib_area->error_text);
/* configure success image */
success_content = clutter_image_new ();
clutter_actor_set_content (calib_area->success_image,
success_content);
g_object_unref (success_content);
clutter_actor_add_child (stage, calib_area->success_image);
clutter_actor_add_constraint (calib_area->success_image,
clutter_align_constraint_new (stage,
CLUTTER_ALIGN_BOTH,
.5));
/* animate clock */
calib_area->clock_timeline = clutter_property_transition_new ("angle");
clutter_timeline_set_progress_mode (CLUTTER_TIMELINE (calib_area->clock_timeline),
CLUTTER_LINEAR);
clutter_timeline_set_duration (CLUTTER_TIMELINE (calib_area->clock_timeline),
MAX_TIME);
clutter_transition_set_animatable (calib_area->clock_timeline,
CLUTTER_ANIMATABLE (calib_area->clock));
clutter_transition_set_from (calib_area->clock_timeline, G_TYPE_FLOAT, .0);
clutter_transition_set_to (calib_area->clock_timeline, G_TYPE_FLOAT, 360.0);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (calib_area->clock_timeline),
-1);
clutter_timeline_start (CLUTTER_TIMELINE (calib_area->clock_timeline));
g_signal_connect (CLUTTER_TIMELINE (calib_area->clock_timeline),
"completed",
G_CALLBACK (on_timeout),
calib_area);
g_signal_connect (stage,
"button-press-event",
G_CALLBACK (on_button_press_event),
calib_area);
g_signal_connect (stage,
"key-release-event",
G_CALLBACK (on_key_release_event),
calib_area);
}
int
main (int argc, char *argv[])
{
ClutterActor *stage, *box;
ClutterLayoutManager *layout;
GError *error;
gint i;
error = NULL;
if (clutter_init_with_args (&argc, &argv,
NULL,
entries,
NULL,
&error) != CLUTTER_INIT_SUCCESS)
{
g_print ("Unable to run flow-layout: %s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
stage = clutter_stage_new ();
clutter_actor_set_background_color (stage, CLUTTER_COLOR_LightSkyBlue);
clutter_stage_set_title (CLUTTER_STAGE (stage), "Flow Layout");
clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
layout = clutter_flow_layout_new (vertical ? CLUTTER_FLOW_VERTICAL
: CLUTTER_FLOW_HORIZONTAL);
clutter_flow_layout_set_homogeneous (CLUTTER_FLOW_LAYOUT (layout),
is_homogeneous);
clutter_flow_layout_set_column_spacing (CLUTTER_FLOW_LAYOUT (layout),
x_spacing);
clutter_flow_layout_set_row_spacing (CLUTTER_FLOW_LAYOUT (layout),
y_spacing);
box = clutter_actor_new ();
clutter_actor_set_layout_manager (box, layout);
clutter_actor_set_background_color (box, CLUTTER_COLOR_Aluminium2);
clutter_actor_add_child (stage, box);
if (!fixed_size)
clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0.0));
clutter_actor_set_position (box, 0, 0);
clutter_actor_set_name (box, "box");
for (i = 0; i < n_rects; i++)
{
ClutterColor color = CLUTTER_COLOR_INIT (255, 255, 255, 255);
gfloat width, height;
ClutterActor *rect;
gchar *name;
name = g_strdup_printf ("rect%02d", i);
clutter_color_from_hls (&color,
360.0 / n_rects * i,
0.5,
0.8);
rect = clutter_actor_new ();
clutter_actor_set_background_color (rect, &color);
if (random_size)
{
width = g_random_int_range (50, 100);
height = g_random_int_range (50, 100);
}
else
width = height = 50.f;
clutter_actor_set_size (rect, width, height);
clutter_actor_set_name (rect, name);
clutter_actor_add_child (box, rect);
g_free (name);
}
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterActor *texture;
ClutterActor *overlay;
ClutterAction *click;
GError *error = NULL;
const gchar *filename = "redhand.png";
if (argc > 1)
filename = 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_texture_set_keep_aspect_ratio (CLUTTER_TEXTURE (texture), TRUE);
clutter_actor_set_reactive (texture, TRUE);
clutter_actor_set_size (texture, RECTANGLE_SIDE, RECTANGLE_SIDE);
clutter_actor_add_constraint (texture, clutter_align_constraint_new (stage, CLUTTER_ALIGN_X_AXIS, 0.5));
clutter_actor_add_constraint (texture, clutter_align_constraint_new (stage, CLUTTER_ALIGN_Y_AXIS, 0.5));
clutter_texture_set_from_file (CLUTTER_TEXTURE (texture),
filename,
&error);
if (error != NULL)
{
g_warning ("Error loading %s\n%s", filename, error->message);
g_error_free (error);
exit (EXIT_FAILURE);
}
/* overlay is 10px wider and taller than the texture, and centered on it;
* initially, it is transparent; but it is made semi-opaque when the
* texture is clicked
*/
overlay = clutter_rectangle_new_with_color (&overlay_color);
clutter_actor_set_opacity (overlay, OVERLAY_OPACITY_OFF);
clutter_actor_add_constraint (overlay, clutter_bind_constraint_new (texture, CLUTTER_BIND_WIDTH, 10));
clutter_actor_add_constraint (overlay, clutter_bind_constraint_new (texture, CLUTTER_BIND_HEIGHT, 10));
clutter_actor_add_constraint (overlay, clutter_align_constraint_new (texture, CLUTTER_ALIGN_X_AXIS, 0.5));
clutter_actor_add_constraint (overlay, clutter_align_constraint_new (texture, CLUTTER_ALIGN_Y_AXIS, 0.5));
click = clutter_click_action_new ();
clutter_actor_add_action (texture, click);
clutter_container_add (CLUTTER_CONTAINER (stage), texture, overlay, NULL);
clutter_actor_raise_top (overlay);
g_signal_connect (click, "clicked", G_CALLBACK (click_cb), overlay);
g_signal_connect (stage,
"key-press-event",
G_CALLBACK (key_press_cb),
texture);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
WindowPanel::WindowPanel()
: auto_hide_(false) {
ClutterLayoutManager * main_layout = clutter_bin_layout_new(CLUTTER_BIN_ALIGNMENT_FIXED,
CLUTTER_BIN_ALIGNMENT_FIXED);
actor_ = clutter_box_new(main_layout);
ClutterActor * menu = clutter_cairo_texture_new(110, 22);
clutter_actor_set_position(menu, 10.0f, 0.0f);
cairo_t * context = clutter_cairo_texture_create(CLUTTER_CAIRO_TEXTURE(menu));
cairo_move_to(context, 0.0, 0.0);
cairo_line_to(context, 0.0, 19.0);
cairo_curve_to(context, 1.0, 21.0, 2.0, 22.0, 3.0, 22.0);
cairo_line_to(context, 107.0, 22.0);
cairo_curve_to(context, 108.0, 22.0, 109.0, 21.0, 110.0, 19.0);
cairo_line_to(context, 110.0, 0.0);
cairo_close_path(context);
cairo_set_source_rgb(context, 0.8, 0.8, 0.8);
cairo_fill_preserve(context);
cairo_set_line_width(context, 1.0);
cairo_set_source_rgb(context, 0.0, 0.0, 0.0);
cairo_stroke(context);
cairo_select_font_face(context, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
cairo_set_font_size(context, 12.0);
cairo_text_extents_t extents;
cairo_text_extents(context, DISPLAY_NAME, &extents);
cairo_move_to(context, 55.0 - ((extents.width / 2.0) + extents.x_bearing),
11.0 - ((extents.height / 2.0) + extents.y_bearing));
cairo_text_path(context, DISPLAY_NAME);
cairo_set_source_rgb(context, 0.0, 0.0, 0.0);
cairo_fill(context);
cairo_destroy(context);
clutter_box_pack(CLUTTER_BOX(actor_), menu, NULL, NULL);
ClutterLayoutManager * controls_layout = clutter_box_layout_new();
clutter_box_layout_set_spacing(CLUTTER_BOX_LAYOUT(controls_layout), 10u);
ClutterActor * controls = clutter_box_new(controls_layout);
clutter_actor_add_constraint(controls, clutter_align_constraint_new(clutter_stage_get_default(),
CLUTTER_ALIGN_X_AXIS, 0.95f));
clutter_actor_add_constraint(controls, clutter_bind_constraint_new(clutter_stage_get_default(),
CLUTTER_BIND_Y, 5.0f));
fullscreen_button_ = clutter_cairo_texture_new(18, 16);
clutter_actor_set_reactive(fullscreen_button_, TRUE);
g_signal_connect(fullscreen_button_, "button-press-event", G_CALLBACK(fullscreen_clicked_cb), this);
g_signal_connect(fullscreen_button_, "enter-event", G_CALLBACK(actor_highlight_on_cb), fullscreen_button_);
g_signal_connect(fullscreen_button_, "leave-event", G_CALLBACK(actor_highlight_off_cb), fullscreen_button_);
clutter_box_pack(CLUTTER_BOX(controls), fullscreen_button_, NULL, NULL);
close_button_ = clutter_cairo_texture_new(15, 15);
context = clutter_cairo_texture_create(CLUTTER_CAIRO_TEXTURE(close_button_));
cairo_move_to(context, 1.0, 3.0);
cairo_line_to(context, 3.0, 1.0);
cairo_line_to(context, 8.0, 6.0);
cairo_line_to(context, 13.0, 1.0);
cairo_line_to(context, 15.0, 3.0);
cairo_line_to(context, 10.0, 8.0);
cairo_line_to(context, 15.0, 13.0);
cairo_line_to(context, 13.0, 15.0);
cairo_line_to(context, 8.0, 10.0);
cairo_line_to(context, 3.0, 15.0);
cairo_line_to(context, 1.0, 13.0);
cairo_line_to(context, 6.0, 8.0);
cairo_close_path(context);
cairo_set_source_rgb(context, 1.0, 1.0, 1.0);
cairo_fill_preserve(context);
cairo_set_line_width(context, 1.0);
cairo_set_source_rgb(context, 0.0, 0.0, 0.0);
cairo_stroke(context);
cairo_destroy(context);
clutter_actor_set_reactive(close_button_, TRUE);
g_signal_connect(close_button_, "button-press-event", G_CALLBACK(close_clicked_cb), NULL);
g_signal_connect(close_button_, "enter-event", G_CALLBACK(actor_highlight_on_cb), close_button_);
g_signal_connect(close_button_, "leave-event", G_CALLBACK(actor_highlight_off_cb), close_button_);
clutter_box_pack(CLUTTER_BOX(controls), close_button_, NULL, NULL);
draw_window_controls();
clutter_box_pack(CLUTTER_BOX(actor_), controls, NULL, NULL);
g_signal_connect(clutter_stage_get_default(), "fullscreen", G_CALLBACK(fullscreen_status_changed_cb), this);
g_signal_connect(clutter_stage_get_default(), "unfullscreen", G_CALLBACK(fullscreen_status_changed_cb), this);
g_signal_connect(clutter_stage_get_default(), "motion-event", G_CALLBACK(show_panel_cb), this);
}
int
main (int argc, char *argv[])
{
ClutterActor *stage;
ClutterLayoutManager *layout;
ClutterActor *box;
ClutterActor *rect;
ClutterActor *text;
ClutterState *transitions;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "btn");
clutter_actor_set_background_color (stage, &stage_color);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_FILL,
CLUTTER_BIN_ALIGNMENT_FILL);
box = clutter_actor_new ();
clutter_actor_set_layout_manager (box, layout);
clutter_actor_set_position (box, 25, 25);
clutter_actor_set_reactive (box, TRUE);
clutter_actor_set_size (box, 100, 30);
/* background for the button */
rect = clutter_rectangle_new_with_color (&yellow);
clutter_actor_add_child (box, rect);
/* text for the button */
text = clutter_text_new_full ("Sans 10pt", "Hover me", &white);
/*
* NB don't set the height, so the actor assumes the height of the text;
* then when added to the bin layout, it gets centred on it;
* also if you don't set the width, the layout goes gets really wide;
* the 10pt text fits inside the 30px height of the rectangle
*/
clutter_actor_set_width (text, 100);
clutter_bin_layout_add (CLUTTER_BIN_LAYOUT (layout),
text,
CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
/* animations */
transitions = clutter_state_new ();
clutter_state_set (transitions, NULL, "fade-out",
box, "opacity", CLUTTER_LINEAR, 180,
NULL);
/*
* NB you can't use an easing mode where alpha > 1.0 if you're
* animating to a value of 255, as the value you're animating
* to will possibly go > 255
*/
clutter_state_set (transitions, NULL, "fade-in",
box, "opacity", CLUTTER_LINEAR, 255,
NULL);
clutter_state_set_duration (transitions, NULL, NULL, 50);
clutter_state_warp_to_state (transitions, "fade-out");
g_signal_connect (box,
"enter-event",
G_CALLBACK (_pointer_enter_cb),
transitions);
g_signal_connect (box,
"leave-event",
G_CALLBACK (_pointer_leave_cb),
transitions);
/* bind the stage size to the box size + 50px in each axis */
clutter_actor_add_constraint (stage, clutter_bind_constraint_new (box, CLUTTER_BIND_HEIGHT, 50.0));
clutter_actor_add_constraint (stage, clutter_bind_constraint_new (box, CLUTTER_BIND_WIDTH, 50.0));
clutter_actor_add_child (stage, box);
clutter_actor_show (stage);
clutter_main ();
g_object_unref (transitions);
return 0;
}
int main(int argc, char *argv[])
{
ClutterActor *stage;
WebKitWebView *web_view;
ClutterConstraint *width_binding;
ClutterConstraint *height_binding;
ClutterConstraint *web_view_height_binding;
gfloat stageWidth, stageHeight;
ClutterActorBox stageAllocation;
ClutterLayoutManager *mainLayout;
ClutterActor *mainLayoutContainer;
ClutterLayoutManager *toolbarLayout;
ClutterActor *toolbarContainer;
ClutterLayoutManager *toolbarBinLayout;
ClutterActor *toolbarBinContainer;
ClutterActor *toolbarBgr;
ClutterActor *statusBar;
ClutterActor *backFwdBtns;
ClutterActor *backBtn;
ClutterActor *fwdBtn;
ClutterActor *uriGroup;
ClutterActor *uriBgr;
ClutterActor *uriText;
ClutterActor *spacer;
GError *error = NULL;
ClutterColor whiteColor = { 255, 255, 255, 255 };
ClutterColor blackColor = { 0, 0, 0, 255 };
ClutterColor grayColor = { 200, 200, 200, 255 };
ClutterColor transparentColor = { 0, 0, 0, 0 };
gchar *toolbarBgrPath = clutter_launcher_file_path("toolbar_bgr.png");
gchar *backBtnPath = clutter_launcher_file_path("back_btn.png");
gchar *fwdBtnPath = clutter_launcher_file_path("fwd_btn.png");
g_thread_init(NULL);
clutter_threads_init();
clutter_init(&argc, &argv);
stage = clutter_stage_get_default();
clutter_actor_set_size(stage, 1024, 768);
clutter_stage_set_color(CLUTTER_STAGE(stage), &stage_color);
g_signal_connect (stage, "destroy", G_CALLBACK(clutter_main_quit), NULL);
/* make the stage resizable */
clutter_stage_set_user_resizable(CLUTTER_STAGE(stage), TRUE);
clutter_actor_show(stage);
mainLayout = clutter_box_layout_new();
clutter_box_layout_set_vertical(CLUTTER_BOX_LAYOUT(mainLayout), TRUE);
clutter_actor_get_allocation_box(stage, &stageAllocation);
stageWidth = stageAllocation.x2 - stageAllocation.x1;
stageHeight = stageAllocation.y2 - stageAllocation.y1;
web_view = WEBKIT_WEB_VIEW(webkit_web_view_new((guint)stageWidth, (guint)stageHeight - (toolbarHeight + statusBarHeight)));
g_object_set(web_view, "reactive", TRUE, NULL);
mainLayoutContainer = clutter_box_new(mainLayout);
clutter_actor_set_size(mainLayoutContainer, stageWidth, stageHeight);
width_binding = clutter_bind_constraint_new(stage, CLUTTER_BIND_WIDTH, 0);
height_binding = clutter_bind_constraint_new(stage, CLUTTER_BIND_HEIGHT, 0);
/* web_view_height_binding = clutter_bind_constraint_new(stage, CLUTTER_BIND_HEIGHT, -(toolbarHeight + statusBarHeight));
*/
clutter_actor_add_constraint(mainLayoutContainer, width_binding);
clutter_actor_add_constraint(mainLayoutContainer, height_binding);
/* clutter_actor_add_constraint(CLUTTER_ACTOR(web_view), web_view_height_binding);
*/
toolbarBinLayout = clutter_bin_layout_new(CLUTTER_BIN_ALIGNMENT_FILL, CLUTTER_BIN_ALIGNMENT_CENTER);
toolbarBinContainer = clutter_box_new(toolbarBinLayout);
toolbarBgr = clutter_texture_new_from_file(toolbarBgrPath, &error);
if (toolbarBgr == NULL) {
fprintf(stderr, "Can't load file: %s. Aborting...\n", toolbarBgrPath);
exit(1);
}
clutter_actor_set_height(toolbarBgr, toolbarHeight);
clutter_texture_set_repeat(CLUTTER_TEXTURE(toolbarBgr), TRUE, FALSE);
clutter_box_pack(CLUTTER_BOX(toolbarBinContainer), toolbarBgr, NULL, NULL);
toolbarLayout = clutter_box_layout_new();
clutter_box_layout_set_vertical(CLUTTER_BOX_LAYOUT(toolbarLayout), FALSE);
clutter_box_layout_set_spacing(CLUTTER_BOX_LAYOUT(toolbarLayout), 16);
toolbarContainer = clutter_box_new(toolbarLayout);
spacer = clutter_rectangle_new_with_color(&transparentColor);
clutter_actor_set_size(spacer, 1, 1);
clutter_box_pack(CLUTTER_BOX(toolbarContainer), spacer, NULL, NULL);
backFwdBtns = clutter_group_new();
backBtn = clutter_texture_new_from_file(backBtnPath, &error);
if (backBtn == NULL) {
fprintf(stderr, "Can't load file: %s. Aborting...\n", backBtnPath);
exit(1);
}
clutter_actor_set_reactive(backBtn, TRUE);
/* connect the release event */
g_signal_connect (backBtn,
"button-release-event",
G_CALLBACK (on_back_release_cb),
web_view);
fwdBtn = clutter_texture_new_from_file(fwdBtnPath, &error);
if (fwdBtn == NULL) {
fprintf(stderr, "Can't load file: %s. Aborting...\n", fwdBtnPath);
exit(1);
}
clutter_actor_set_reactive(fwdBtn, TRUE);
/* connect the release event */
g_signal_connect (fwdBtn,
"button-release-event",
G_CALLBACK (on_fwd_release_cb),
web_view);
clutter_actor_set_position(fwdBtn,
clutter_actor_get_width(backBtn), 0);
clutter_container_add(CLUTTER_CONTAINER(backFwdBtns), backBtn, fwdBtn, NULL);
clutter_box_pack(CLUTTER_BOX(toolbarContainer), backFwdBtns, NULL, NULL);
uriGroup = clutter_group_new();
uriBgr = clutter_rectangle_new_with_color(&whiteColor);
clutter_rectangle_set_border_color(CLUTTER_RECTANGLE(uriBgr), &blackColor);
clutter_rectangle_set_border_width(CLUTTER_RECTANGLE(uriBgr), 1);
clutter_actor_set_size(uriBgr, 400, 25);
uriText = clutter_text_new_full("Helvetica 11px", "http://www.google.com", &blackColor);
clutter_text_set_editable(CLUTTER_TEXT(uriText), TRUE);
clutter_text_set_single_line_mode(CLUTTER_TEXT(uriText), TRUE);
clutter_actor_set_position(uriText, 5, 7);
clutter_actor_set_size(uriText, 390, 17);
clutter_actor_set_reactive(uriText, TRUE);
g_signal_connect(uriText, "activate", G_CALLBACK(on_uri_activate_cb), web_view);
clutter_container_add(CLUTTER_CONTAINER(uriGroup), uriBgr, uriText, NULL);
clutter_box_pack(CLUTTER_BOX(toolbarContainer), uriGroup, NULL, NULL);
clutter_box_pack(CLUTTER_BOX(toolbarBinContainer), toolbarContainer, NULL, NULL);
clutter_box_pack(CLUTTER_BOX(mainLayoutContainer), toolbarBinContainer,
"y-align", CLUTTER_BOX_ALIGNMENT_START, NULL);
clutter_box_layout_set_expand(CLUTTER_BOX_LAYOUT(mainLayout), toolbarBinContainer, TRUE);
clutter_box_layout_set_fill(CLUTTER_BOX_LAYOUT(mainLayout), toolbarBinContainer, TRUE, FALSE);
statusBar = clutter_rectangle_new_with_color(&grayColor);
clutter_actor_set_height(statusBar, statusBarHeight);
clutter_box_pack(CLUTTER_BOX(mainLayoutContainer), statusBar,
"y-align", CLUTTER_BOX_ALIGNMENT_END, NULL);
clutter_box_layout_set_expand(CLUTTER_BOX_LAYOUT(mainLayout), statusBar, TRUE);
clutter_box_layout_set_fill(CLUTTER_BOX_LAYOUT(mainLayout), statusBar, TRUE, FALSE);
clutter_box_pack_after(CLUTTER_BOX(mainLayoutContainer), CLUTTER_ACTOR(web_view), toolbarBinContainer,
"y-align", CLUTTER_BOX_ALIGNMENT_START, NULL);
clutter_box_layout_set_expand(CLUTTER_BOX_LAYOUT(mainLayout), CLUTTER_ACTOR(web_view), TRUE);
clutter_box_layout_set_fill(CLUTTER_BOX_LAYOUT(mainLayout), CLUTTER_ACTOR(web_view), TRUE, TRUE);
clutter_container_add(CLUTTER_CONTAINER(stage), mainLayoutContainer, NULL);
g_signal_connect(web_view, "webkit-load-finished", G_CALLBACK(load_finished_cb), web_view);
g_signal_connect(web_view, "notify::progress", G_CALLBACK (notify_progress_cb), web_view);
/* g_signal_connect(stage, "delete-event", G_CALLBACK(delete_cb), web_view);*/
g_signal_connect(web_view, "notify::uri", G_CALLBACK(notify_uri_cb), uriText);
gchar *uri = (gchar*) (argc > 1 ? argv[1] : "http://www.google.com/");
gchar *fileURL = filenameToURL(uri);
webkit_web_view_load_uri(web_view, fileURL ? fileURL : uri);
printf("%s\n", fileURL ? fileURL : uri);
g_free(fileURL);
g_timeout_add_full(G_PRIORITY_DEFAULT, 3000, timeout_cb, web_view, 0);
clutter_threads_enter ();
clutter_main();
clutter_threads_leave ();
return EXIT_SUCCESS;
}
G_MODULE_EXPORT gint
test_text_field_main (gint argc,
gchar **argv)
{
ClutterActor *stage;
ClutterActor *box, *label, *entry;
ClutterLayoutManager *table;
PangoAttrList *entry_attrs;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return EXIT_FAILURE;
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Text Fields");
clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
table = clutter_table_layout_new ();
clutter_table_layout_set_column_spacing (CLUTTER_TABLE_LAYOUT (table), 6);
clutter_table_layout_set_row_spacing (CLUTTER_TABLE_LAYOUT (table), 6);
box = clutter_actor_new ();
clutter_actor_set_layout_manager (box, table);
clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_WIDTH, -24.0));
clutter_actor_add_constraint (box, clutter_bind_constraint_new (stage, CLUTTER_BIND_HEIGHT, -24.0));
clutter_actor_set_position (box, 12, 12);
clutter_actor_add_child (stage, box);
label = create_label (CLUTTER_COLOR_White, "<b>Input field:</b>");
g_object_set (label, "min-width", 150.0, NULL);
clutter_actor_add_child (box, label);
clutter_layout_manager_child_set (table, CLUTTER_CONTAINER (box), label,
"row", 0,
"column", 0,
"x-expand", FALSE,
"y-expand", FALSE,
NULL);
entry_attrs = pango_attr_list_new ();
pango_attr_list_insert (entry_attrs, pango_attr_underline_new (PANGO_UNDERLINE_ERROR));
pango_attr_list_insert (entry_attrs, pango_attr_underline_color_new (65535, 0, 0));
entry = create_entry (CLUTTER_COLOR_Black, "somme misspeeled textt", entry_attrs, 0, 0);
clutter_actor_add_child (box, entry);
clutter_layout_manager_child_set (table, CLUTTER_CONTAINER (box), entry,
"row", 0,
"column", 1,
"x-expand", TRUE,
"x-fill", TRUE,
"y-expand", FALSE,
NULL);
clutter_actor_grab_key_focus (entry);
label = create_label (CLUTTER_COLOR_White, "<b>A very long password field:</b>");
clutter_actor_add_child (box, label);
clutter_layout_manager_child_set (table, CLUTTER_CONTAINER (box), label,
"row", 1,
"column", 0,
"x-expand", FALSE,
"y-expand", FALSE,
NULL);
entry = create_entry (CLUTTER_COLOR_Black, "password", NULL, '*', 8);
clutter_actor_add_child (box, entry);
clutter_layout_manager_child_set (table, CLUTTER_CONTAINER (box), entry,
"row", 1,
"column", 1,
"x-expand", TRUE,
"x-fill", TRUE,
"y-expand", FALSE,
NULL);
clutter_actor_show (stage);
clutter_main ();
return EXIT_SUCCESS;
}
