static ClutterActor* do_marker_icon (gchar *name, int size)
{
GtkIconTheme *theme;
GtkIconInfo *icon_info;
GdkPixbuf *pixbuf;
ClutterActor *ret;
ClutterContent *icon;
ret = clutter_actor_new ();
theme = gtk_icon_theme_get_default ();
icon_info = gtk_icon_theme_lookup_icon (theme, name, size, 0);
if (icon_info != NULL) {
pixbuf = gdk_pixbuf_new_from_file (gtk_icon_info_get_filename (icon_info), NULL);
icon = clutter_image_new ();
clutter_image_set_data (CLUTTER_IMAGE (icon),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
NULL);
g_object_unref (pixbuf);
clutter_actor_set_content (ret, icon);
g_object_unref (icon);
}
return ret;
}
static ClutterActor *
create_content_actor (void)
{
ClutterActor *content;
ClutterContent *image;
GdkPixbuf *pixbuf;
content = clutter_actor_new ();
clutter_actor_set_size (content, 720, 720);
pixbuf = gdk_pixbuf_new_from_file (TESTS_DATADIR G_DIR_SEPARATOR_S "redhand.png", NULL);
image = clutter_image_new ();
clutter_image_set_data (CLUTTER_IMAGE (image),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
NULL);
g_object_unref (pixbuf);
clutter_actor_set_content_scaling_filters (content,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
clutter_actor_set_content_gravity (content, CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT);
clutter_actor_set_content (content, image);
g_object_unref (image);
return content;
}
ClutterActor *
ckd_slide_new_for_poppler_page (PopplerPage *page, gdouble scale)
{
CkdSlide *self = g_object_new (CKD_TYPE_SLIDE, NULL);
CkdSlidePriv *priv = CKD_SLIDE_GET_PRIVATE (self);
ClutterContent *canvas;
gdouble w, h;
priv->content = clutter_actor_new ();
canvas = clutter_canvas_new ();
poppler_page_get_size (page, &w, &h);
clutter_canvas_set_size (CLUTTER_CANVAS(canvas), w * scale, h * scale);
clutter_actor_set_content (priv->content, canvas);
clutter_actor_set_content_scaling_filters (priv->content,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
g_object_unref (canvas);
clutter_actor_set_size (priv->content, w * scale, h * scale);
clutter_actor_add_child (CLUTTER_ACTOR(self), priv->content);
struct CkdDrawData data = {page, scale};
g_signal_connect (canvas, "draw", G_CALLBACK (draw_page), &data);
clutter_content_invalidate (canvas);
return (ClutterActor *)self;
}
gint
main (gint argc,
gchar *argv[])
{
ClutterContent *image;
ClutterActor *stage;
ClutterActor *box;
GdkPixbuf *pixbuf;
if (clutter_init(&argc, &argv) != CLUTTER_INIT_SUCCESS) {
g_printerr("Failed to initialize clutter.\n");
return 1;
}
stage = clutter_stage_new();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Image Viewer");
clutter_actor_set_size(stage, 1400, 1200);
clutter_actor_set_position(stage, 100, 100);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
clutter_actor_show(stage);
pixbuf = gdk_pixbuf_new_from_file("testimage_8000.png", NULL);
g_assert(pixbuf);
image = clutter_image_new();
clutter_image_set_data(CLUTTER_IMAGE(image),
gdk_pixbuf_get_pixels(pixbuf),
gdk_pixbuf_get_has_alpha(pixbuf) ?
COGL_PIXEL_FORMAT_RGBA_8888 :
COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf),
gdk_pixbuf_get_rowstride(pixbuf),
NULL);
g_object_unref(pixbuf);
box = clutter_actor_new();
clutter_actor_set_position(box, 0, 0);
clutter_actor_set_height(box, 8000);
clutter_actor_set_width(box, 1200);
//clutter_actor_add_constraint(box, clutter_bind_constraint_new(stage, CLUTTER_BIND_WIDTH, 0.0));
clutter_actor_set_content(box, image);
clutter_actor_add_child(stage, box);
clutter_actor_show(box);
clutter_stage_set_fullscreen(CLUTTER_STAGE(stage), TRUE);
clutter_actor_animate(box,
CLUTTER_EASE_IN_OUT_QUAD,
4000,
"y", -8000.0,
NULL);
clutter_main();
return 0;
}
static void
champlain_path_layer_init (ChamplainPathLayer *self)
{
ChamplainPathLayerPrivate *priv;
self->priv = GET_PRIVATE (self);
priv = self->priv;
priv->view = NULL;
priv->visible = TRUE;
priv->fill = FALSE;
priv->stroke = TRUE;
priv->stroke_width = 2.0;
priv->nodes = NULL;
priv->dash = NULL;
priv->num_dashes = 0;
priv->redraw_scheduled = FALSE;
priv->fill_color = clutter_color_copy (&DEFAULT_FILL_COLOR);
priv->stroke_color = clutter_color_copy (&DEFAULT_STROKE_COLOR);
priv->right_canvas = clutter_canvas_new ();
priv->left_canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (priv->right_canvas), 255, 255);
clutter_canvas_set_size (CLUTTER_CANVAS (priv->left_canvas), 0, 0);
g_signal_connect (priv->right_canvas, "draw", G_CALLBACK (redraw_path), self);
g_signal_connect (priv->left_canvas, "draw", G_CALLBACK (redraw_path), self);
priv->path_actor = clutter_actor_new ();
clutter_actor_add_child (CLUTTER_ACTOR (self), priv->path_actor);
clutter_actor_set_size (priv->path_actor, 255, 255);
priv->right_actor = clutter_actor_new ();
clutter_actor_set_size (priv->right_actor, 255, 255);
clutter_actor_set_content (priv->right_actor, priv->right_canvas);
clutter_actor_add_child (priv->path_actor, priv->right_actor);
priv->left_actor = clutter_actor_new ();
clutter_actor_set_size (priv->left_actor, 255, 255);
clutter_actor_set_content (priv->left_actor, priv->left_canvas);
clutter_actor_add_child (priv->path_actor, priv->left_actor);
}
static void meta_switcher_present_list(MetaSwitcher* self)
{
MetaSwitcherPrivate* priv = self->priv;
MetaScreen* screen = meta_plugin_get_screen(priv->plugin);
MetaDisplay* display = meta_screen_get_display(screen);
// windows on all workspaces
GList* ls = meta_display_get_tab_list(display, META_TAB_LIST_NORMAL, NULL);
if (!ls) return;
GList* ws_list = meta_screen_get_workspaces(screen);
g_list_foreach(ws_list, (GFunc)hook_ws_event, self);
if (!priv->apps) {
priv->apps = g_ptr_array_new();
GList* orig = ls;
while (ls) {
g_ptr_array_add(priv->apps, ls->data);
ls = ls->next;
}
g_list_free(orig);
}
clutter_actor_set_height(priv->top, APP_ACTOR_HEIGHT + 20);
gint x = 0, y = 0;
for (int i = 0; i < priv->apps->len; i++) {
_add_app(self, g_ptr_array_index(priv->apps, i), &x, &y);
}
clutter_actor_set_margin_left(g_hash_table_lookup(priv->icons, g_ptr_array_index(priv->apps, 0)), 10);
clutter_actor_set_margin_right(g_hash_table_lookup(priv->icons, g_ptr_array_index(priv->apps, priv->apps->len-1)), 10);
gint screen_width = 0, screen_height = 0;
meta_screen_get_size(screen, &screen_width, &screen_height);
/* TODO: @sonald set top width when bigger than screen width */
if (clutter_actor_get_width(priv->top) > screen_width)
clutter_actor_set_width(priv->top, screen_width);
gfloat w = clutter_actor_get_width(priv->top), h = clutter_actor_get_height(priv->top),
tx = (screen_width - w) / 2, ty = (screen_height - h) / 2;
#if DEBUG
g_message("%s, line %d, %f %f", __func__, __LINE__, w, tx);
#endif
clutter_actor_set_position(priv->top, tx, ty);
ClutterContent* canvas = clutter_canvas_new();
clutter_canvas_set_size(CLUTTER_CANVAS(canvas), w, h);
clutter_actor_set_content(priv->top, canvas);
g_object_unref(canvas);
g_signal_connect(canvas, "draw", G_CALLBACK(on_switcher_background_draw), self);
clutter_content_invalidate(canvas);
priv->selected_id = 0;
}
ClutterActor *
ckd_slide_new_for_image (GFile *file)
{
CkdSlide *self = g_object_new (CKD_TYPE_SLIDE, NULL);
CkdSlidePriv *priv = CKD_SLIDE_GET_PRIVATE (self);
GdkPixbuf *pixbuf;
ClutterContent *image;
/* 载入图像数据 */
gchar *image_path = g_file_get_path (file);
pixbuf = gdk_pixbuf_new_from_file (image_path, NULL);
/* 获取图像尺寸 */
gfloat w = gdk_pixbuf_get_width (pixbuf);
gfloat h = gdk_pixbuf_get_height (pixbuf);
image = clutter_image_new ();
clutter_image_set_data (CLUTTER_IMAGE (image),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
(guint)w,
(guint)h,
gdk_pixbuf_get_rowstride (pixbuf),
NULL);
g_object_unref (pixbuf);
g_free (image_path);
priv->content = clutter_actor_new ();
clutter_actor_set_size (priv->content, w, h);
clutter_actor_set_content_scaling_filters (priv->content,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
clutter_actor_set_content (priv->content, image);
g_object_unref (image);
clutter_actor_add_child (CLUTTER_ACTOR(self), priv->content);
return (ClutterActor *)self;
}
static void
champlain_point_init (ChamplainPoint *point)
{
ChamplainPointPrivate *priv = GET_PRIVATE (point);
point->priv = priv;
priv->color = clutter_color_copy (&DEFAULT_COLOR);
priv->size = 12;
priv->canvas = clutter_canvas_new ();
g_signal_connect (priv->canvas, "draw", G_CALLBACK (draw), point);
clutter_canvas_set_size (CLUTTER_CANVAS (priv->canvas), priv->size, priv->size);
clutter_actor_set_size (CLUTTER_ACTOR (point), priv->size, priv->size);
clutter_actor_set_content (CLUTTER_ACTOR (point), priv->canvas);
clutter_actor_set_translation (CLUTTER_ACTOR (point), -priv->size/2, -priv->size/2, 0.0);
clutter_content_invalidate (priv->canvas);
g_signal_connect (point, "notify::selected", G_CALLBACK (notify_selected), NULL);
}
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);
}
//FIXME: ClutterClone seems to have problem rendering children, so badges are stay in grandpar
static void create_window_badge(MosesOverview* self, ClutterActor* parent, int order)
{
ClutterActor* badge = clutter_actor_new();
clutter_actor_insert_child_above(clutter_actor_get_parent(parent), badge, NULL);
gfloat tw, th;
clutter_actor_get_transformed_size(parent, &tw, &th);
gfloat w = 60.0, h = 60.0,
x = (tw - w) / 2.0 + clutter_actor_get_x(parent),
y = (th - h) / 2.0 + clutter_actor_get_y(parent);
clutter_actor_set_position(badge, x, y);
clutter_actor_set_size(badge, w, h);
g_object_set_qdata(G_OBJECT(badge), moses_overview_window_clone_order(), GINT_TO_POINTER(order));
g_object_set_qdata(G_OBJECT(parent), moses_overview_window_clone_order(), GINT_TO_POINTER(order));
ClutterContent* canvas = clutter_canvas_new();
clutter_canvas_set_size(CLUTTER_CANVAS(canvas), w, h);
clutter_actor_set_content(badge, canvas);
g_object_unref(canvas);
g_signal_connect(canvas, "draw", G_CALLBACK(on_badge_draw), badge);
clutter_content_invalidate(canvas);
clutter_actor_set_scale(badge, 0.0, 0.0);
//do animated show
clutter_actor_save_easing_state(badge);
clutter_actor_set_easing_mode(badge, CLUTTER_EASE_OUT_BACK);
clutter_actor_set_easing_duration(badge, 350);
clutter_actor_set_pivot_point(badge, 0.5, 0.5);
clutter_actor_set_scale(badge, 1.0, 1.0);
clutter_actor_restore_easing_state(badge);
g_ptr_array_add(self->priv->badges, badge);
}
static void
bacon_video_osd_actor_init (BaconVideoOsdActor *osd)
{
ClutterActor *self;
GtkWidgetPath *widget_path;
self = CLUTTER_ACTOR (osd);
osd->priv = BACON_VIDEO_OSD_ACTOR_GET_PRIVATE (osd);
osd->priv->canvas = CLUTTER_CANVAS (clutter_canvas_new ());
g_object_bind_property (self, "width",
osd->priv->canvas, "width",
G_BINDING_DEFAULT);
g_object_bind_property (self, "height",
osd->priv->canvas, "height",
G_BINDING_DEFAULT);
clutter_actor_set_content (self, CLUTTER_CONTENT (osd->priv->canvas));
g_object_unref (osd->priv->canvas);
osd->priv->icon_name = NULL;
osd->priv->message = NULL;
osd->priv->ctx = g_new0 (GsdOsdDrawContext, 1);
widget_path = gtk_widget_path_new ();
gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW);
osd->priv->style = gtk_style_context_new ();
gtk_style_context_set_path (osd->priv->style, widget_path);
gtk_widget_path_free (widget_path);
osd->priv->ctx->direction = clutter_get_default_text_direction ();
osd->priv->ctx->theme = gtk_icon_theme_get_default ();
osd->priv->ctx->style = osd->priv->style;
g_signal_connect (osd->priv->canvas, "draw", G_CALLBACK (bacon_video_osd_actor_draw), osd);
osd->priv->fade_out_alpha = 1.0;
}
int
main (int argc, char *argv[])
{
ClutterActor *stage, *box, *bg, *icon, *emblem, *label;
ClutterLayoutManager *layout;
ClutterContent *canvas, *image;
ClutterColor *color;
ClutterAction *action;
GdkPixbuf *pixbuf;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
/* prepare the stage */
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "BinLayout");
clutter_actor_set_background_color (stage, CLUTTER_COLOR_Aluminium2);
clutter_actor_set_size (stage, 640, 480);
clutter_actor_show (stage);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* this is our BinLayout, with its default alignments */
layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER,
CLUTTER_BIN_ALIGNMENT_CENTER);
/* the main container; this actor will use the BinLayout to lay
* out its children; we use the anchor point to keep it centered
* on the same position even when we change its size
*/
box = clutter_actor_new ();
clutter_actor_set_layout_manager (box, layout);
clutter_actor_add_constraint (box, clutter_align_constraint_new (stage, CLUTTER_ALIGN_BOTH, 0.5));
clutter_actor_set_position (box, 320, 240);
clutter_actor_set_reactive (box, TRUE);
clutter_actor_set_name (box, "box");
clutter_actor_add_child (stage, box);
/* the background is drawn using a canvas content */
canvas = clutter_canvas_new ();
g_signal_connect (canvas, "draw", G_CALLBACK (on_canvas_draw), NULL);
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 200, 200);
/* this is the background actor; we want it to fill the whole
* of the allocation given to it by its parent
*/
bg = clutter_actor_new ();
clutter_actor_set_name (bg, "background");
clutter_actor_set_size (bg, 200, 200);
clutter_actor_set_content (bg, canvas);
clutter_actor_set_x_expand (bg, TRUE);
clutter_actor_set_y_expand (bg, TRUE);
clutter_actor_set_x_align (bg, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_set_y_align (bg, CLUTTER_ACTOR_ALIGN_FILL);
clutter_actor_add_child (box, bg);
/* we use the ::transitions-completed signal to get notification
* of the end of the sizing animation; this allows us to redraw
* the canvas only once the animation has stopped
*/
g_signal_connect (box, "transitions-completed",
G_CALLBACK (redraw_canvas),
canvas);
/* we use GdkPixbuf to load an image from our data directory */
pixbuf = gdk_pixbuf_new_from_file (TESTS_DATADIR G_DIR_SEPARATOR_S "redhand.png", NULL);
image = clutter_image_new ();
clutter_image_set_data (CLUTTER_IMAGE (image),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
NULL);
g_object_unref (pixbuf);
/* this is the icon; it's going to be centered inside the box actor.
* we use the content gravity to keep the aspect ratio of the image,
* and the scaling filters to get a better result when scaling the
* image down.
*/
icon = clutter_actor_new ();
clutter_actor_set_name (icon, "icon");
clutter_actor_set_size (icon, 196, 196);
clutter_actor_set_x_expand (icon, TRUE);
clutter_actor_set_y_expand (icon, TRUE);
clutter_actor_set_x_align (icon, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_align (icon, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_content_gravity (icon, CLUTTER_CONTENT_GRAVITY_RESIZE_ASPECT);
clutter_actor_set_content_scaling_filters (icon,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
clutter_actor_set_content (icon, image);
clutter_actor_add_child (box, icon);
color = clutter_color_new (g_random_int_range (0, 255),
g_random_int_range (0, 255),
g_random_int_range (0, 255),
224);
/* this is the emblem: a small rectangle with a random color, that we
* want to put in the bottom right corner
*/
emblem = clutter_actor_new ();
clutter_actor_set_name (emblem, "emblem");
clutter_actor_set_size (emblem, 48, 48);
clutter_actor_set_background_color (emblem, color);
clutter_actor_set_x_expand (emblem, TRUE);
clutter_actor_set_y_expand (emblem, TRUE);
clutter_actor_set_x_align (emblem, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_set_y_align (emblem, CLUTTER_ACTOR_ALIGN_END);
clutter_actor_set_reactive (emblem, TRUE);
clutter_actor_set_opacity (emblem, 0);
clutter_actor_add_child (box, emblem);
clutter_color_free (color);
/* when clicking on the emblem, we want to perform an action */
action = clutter_click_action_new ();
clutter_actor_add_action (emblem, action);
g_signal_connect (action, "clicked", G_CALLBACK (on_emblem_clicked), box);
g_signal_connect (action, "long-press", G_CALLBACK (on_emblem_long_press), box);
/* whenever the pointer enters the box, we show the emblem; we hide
* the emblem when the pointer leaves the box
*/
g_signal_connect (box,
"enter-event", G_CALLBACK (on_box_enter),
emblem);
g_signal_connect (box,
"leave-event", G_CALLBACK (on_box_leave),
emblem);
/* a label, that we want to position at the top and center of the box */
label = clutter_text_new ();
clutter_actor_set_name (label, "text");
clutter_text_set_text (CLUTTER_TEXT (label), "A simple test");
clutter_actor_set_x_expand (label, TRUE);
clutter_actor_set_x_align (label, CLUTTER_ACTOR_ALIGN_CENTER);
clutter_actor_set_y_expand (label, TRUE);
clutter_actor_set_y_align (label, CLUTTER_ACTOR_ALIGN_START);
clutter_actor_add_child (box, label);
clutter_main ();
return EXIT_SUCCESS;
}
static void
on_monitors_changed (MetaScreen *screen,
MetaPlugin *plugin)
{
MetaDefaultPlugin *self = META_DEFAULT_PLUGIN (plugin);
__attribute__ ((unused)) ClutterAnimation *animation;
int i, n;
gchar *wallpaper = NULL;
GFile *wallpaper_file = NULL;
gchar *filename = NULL;
GDesktopBackgroundStyle style;
GDesktopBackgroundShading shading_direction;
ClutterColor primary_color;
ClutterColor secondary_color;
gboolean random_colour = FALSE;
clutter_actor_destroy_all_children (self->priv->background_group);
wallpaper = g_settings_get_string (self->priv->settings, PICTURE_URI_KEY);
/* We don't currently support slideshows */
if (!wallpaper || g_str_has_suffix(wallpaper, ".xml"))
random_colour = TRUE;
else {
gchar *color_str;
/* Shading direction*/
shading_direction = g_settings_get_enum (self->priv->settings, COLOR_SHADING_TYPE_KEY);
/* Primary color */
color_str = g_settings_get_string (self->priv->settings, PRIMARY_COLOR_KEY);
if (color_str)
{
clutter_color_from_string (&primary_color, color_str);
g_free (color_str);
color_str = NULL;
}
/* Secondary color */
color_str = g_settings_get_string (self->priv->settings, SECONDARY_COLOR_KEY);
if (color_str)
{
clutter_color_from_string (&secondary_color, color_str);
g_free (color_str);
color_str = NULL;
}
/* Picture options: "none", "wallpaper", "centered", "scaled", "stretched", "zoom", "spanned" */
style = g_settings_get_enum (self->priv->settings, BACKGROUND_STYLE_KEY);
wallpaper_file = g_file_new_for_uri(wallpaper);
filename = g_file_get_path(wallpaper_file);
}
n = meta_screen_get_n_monitors (screen);
for (i = 0; i < n; i++)
{
MetaBackground *content;
MetaRectangle rect;
ClutterActor *background;
background = meta_background_actor_new ();
content = meta_background_new (screen,
i,
META_BACKGROUND_EFFECTS_NONE);
// Don't use rand() here, mesa calls srand() internally when
// parsing the driconf XML, but it's nice if the colors are
// reproducible.
if (random_colour)
{
clutter_color_init (&primary_color,
g_random_int () % 255,
g_random_int () % 255,
g_random_int () % 255,
255);
meta_background_load_color (content, &primary_color);
} else {
if (style == G_DESKTOP_BACKGROUND_STYLE_NONE ||
g_str_has_suffix (filename, GNOME_COLOR_HACK))
{
if (shading_direction == G_DESKTOP_BACKGROUND_SHADING_SOLID)
meta_background_load_color (content, &primary_color);
else
meta_background_load_gradient (content,
shading_direction,
&primary_color,
&secondary_color);
} else {
/* Set the background */
meta_background_load_file_async (content,
filename,
style,
NULL, /*TODO use cancellable*/
background_load_file_cb,
self);
}
}
clutter_actor_set_content (background, CLUTTER_CONTENT (content));
g_object_unref (content);
meta_screen_get_monitor_geometry (screen, i, &rect);
clutter_actor_set_position (background, rect.x, rect.y);
clutter_actor_set_size (background, rect.width, rect.height);
clutter_actor_add_child (self->priv->background_group, background);
clutter_actor_set_scale (background, 0.0, 0.0);
clutter_actor_show (background);
clutter_actor_set_pivot_point (background, 0.5, 0.5);
/* Ease in the background using a scale effect */
animation = clutter_actor_animate (background, CLUTTER_EASE_IN_SINE,
BACKGROUND_TIMEOUT,
"scale-x", 1.0,
"scale-y", 1.0,
NULL);
}
if (wallpaper_file)
g_object_unref(wallpaper_file);
g_free(wallpaper);
g_free(filename);
}
void xfdashboard_live_workspace_set_workspace(XfdashboardLiveWorkspace *self, XfdashboardWindowTrackerWorkspace *inWorkspace)
{
XfdashboardLiveWorkspacePrivate *priv;
ClutterContent *content;
XfdashboardWindowTrackerWindow *window;
ClutterActor *child;
ClutterActorIter iter;
GList *windows;
ClutterActor *actor;
g_return_if_fail(XFDASHBOARD_IS_LIVE_WORKSPACE(self));
g_return_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_WORKSPACE(inWorkspace));
priv=self->priv;
/* Only set value if it changes */
if(inWorkspace==priv->workspace) return;
/* Release old value */
if(priv->workspace)
{
g_signal_handlers_disconnect_by_data(priv->workspace, self);
priv->workspace=NULL;
}
/* Set new value
* Window tracker objects should never be refed or unrefed, so just set new value
*/
priv->workspace=inWorkspace;
/* Destroy all window actors */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Get window actor */
if(!CLUTTER_IS_ACTOR(child)) continue;
/* Check if it is really a window actor by retrieving associated window */
content=clutter_actor_get_content(child);
if(!content || !XFDASHBOARD_IS_WINDOW_CONTENT(content)) continue;
/* Destroy window actor */
clutter_actor_destroy(child);
}
/* Create windows for new workspace in stacked order */
windows=xfdashboard_window_tracker_get_windows_stacked(priv->windowTracker);
for( ; windows; windows=g_list_next(windows))
{
/* Get window */
window=XFDASHBOARD_WINDOW_TRACKER_WINDOW(windows->data);
if(!window) continue;
/* Create window actor if window is visible */
if(!_xfdashboard_live_workspace_is_visible_window(self, window)) continue;
actor=clutter_actor_new();
content=xfdashboard_window_content_new_for_window(window);
clutter_actor_set_content(actor, content);
g_object_unref(content);
/* Insert new actor at bottom */
clutter_actor_insert_child_above(CLUTTER_ACTOR(self), actor, NULL);
}
/* Notify about property change */
g_object_notify_by_pspec(G_OBJECT(self), XfdashboardLiveWorkspaceProperties[PROP_WORKSPACE]);
}
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);
}
static void
on_depth_frame (GFreenectDevice *kinect, gpointer user_data)
{
gboolean smoothing_enabled;
gint width, height;
gint dimension_factor;
guchar *grayscale_buffer;
guint16 *depth;
BufferInfo *buffer_info;
gsize len;
GError *error = NULL;
GFreenectFrameMode frame_mode;
ClutterContent *content;
depth = (guint16 *) gfreenect_device_get_depth_frame_raw (kinect,
&len,
&frame_mode);
width = frame_mode.width;
height = frame_mode.height;
g_object_get (skeleton, "dimension-reduction", &dimension_factor, NULL);
buffer_info = process_buffer (depth,
width,
height,
dimension_factor,
THRESHOLD_BEGIN,
THRESHOLD_END);
skeltrack_skeleton_track_joints (skeleton,
buffer_info->reduced_buffer,
buffer_info->reduced_width,
buffer_info->reduced_height,
NULL,
on_track_joints,
buffer_info);
content = clutter_actor_get_content (depth_tex);
if (!SHOW_SKELETON)
{
grayscale_buffer = create_grayscale_buffer (buffer_info,
dimension_factor);
if (depth_image == NULL)
depth_image = clutter_image_new ();
/* ref because we don't want it to be freed */
if (depth_canvas == content)
g_object_ref (depth_canvas);
clutter_actor_set_content (depth_tex, depth_image);
if (! clutter_image_set_data (CLUTTER_IMAGE (depth_image),
grayscale_buffer,
COGL_PIXEL_FORMAT_RGB_888,
width, height,
0,
&error))
{
g_debug ("Error setting texture area: %s", error->message);
g_error_free (error);
}
g_slice_free1 (width * height * sizeof (guchar) * 3, grayscale_buffer);
}
else {
/* ref because we don't want it to be freed */
if (depth_image && depth_image == content)
g_object_ref (depth_image);
clutter_actor_set_content (depth_tex, depth_canvas);
}
}
static void _add_app(MetaSwitcher* self, MetaWindow* app, gint* x, gint* y)
{
MetaSwitcherPrivate* priv = self->priv;
if (!priv->icons)
priv->icons = g_hash_table_new(NULL, NULL);
// container
ClutterActor* actor = clutter_actor_new();
WindowPrivate* win_priv = get_window_private(actor);
win_priv->window = app;
win_priv->highlight = FALSE;
g_hash_table_insert(priv->icons, app, actor);
gint w = APP_ACTOR_WIDTH, h = APP_ACTOR_HEIGHT, screen_width, screen_height;
/* TODO: @sonald scale app actor width */
MetaScreen *screen = meta_plugin_get_screen(priv->plugin);
meta_screen_get_size(screen, &screen_width, &screen_height);
if (priv->apps->len)
w = (screen_width - priv->apps->len * APP_ICON_PADDING) / priv->apps->len;
if (w > APP_ACTOR_WIDTH)
w = APP_ACTOR_WIDTH;
// add children
ClutterContent* canvas = clutter_canvas_new();
g_signal_connect(canvas, "draw", G_CALLBACK(on_icon_background_draw), actor);
clutter_canvas_set_size(CLUTTER_CANVAS(canvas), w, h);
ClutterActor* bg = clutter_actor_new();
clutter_actor_set_name(bg, "bg");
clutter_actor_set_content(bg, canvas);
g_object_unref(canvas);
clutter_actor_set_size(bg, w, h);
g_object_set(bg, "x-expand", TRUE, "y-expand", TRUE, "x-align", CLUTTER_ACTOR_ALIGN_FILL,
"y-align", CLUTTER_ACTOR_ALIGN_FILL, NULL);
clutter_actor_add_child(actor, bg);
ClutterActor* icon = load_icon_for_window(self, app);
if (icon) clutter_actor_add_child(actor, icon);
ClutterActor* label = clutter_text_new();
clutter_actor_add_child(actor, label);
clutter_text_set_text(CLUTTER_TEXT(label), meta_window_get_title(app));
clutter_text_set_font_name(CLUTTER_TEXT(label), "Sans 10");
ClutterColor clr = {0xff, 0xff, 0xff, 0xff};
clutter_text_set_color(CLUTTER_TEXT(label), &clr);
clutter_text_set_ellipsize(CLUTTER_TEXT(label), PANGO_ELLIPSIZE_END);
g_object_set(label, "x-align", CLUTTER_ACTOR_ALIGN_CENTER, "y-align", CLUTTER_ACTOR_ALIGN_CENTER, NULL);
gfloat pref_width = clutter_actor_get_width(label);
if (pref_width > w - 10) {
pref_width = w - 10;
clutter_actor_set_width(label, pref_width);
}
/* TODO: @sonald adjust app title position */
clutter_actor_set_position(label, (w - pref_width) / 2, APP_ICON_SIZE + 2);
g_debug("%s: size: %d, %d", __func__, w, h);
clutter_actor_show(actor);
clutter_actor_add_child(priv->top, actor);
*x += w;
}
int
main (int argc, char *argv[])
{
ClutterActor *stage, *actor;
ClutterContent *canvas;
ClutterTransition *transition;
/* initialize Clutter */
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return EXIT_FAILURE;
/* create a stage */
stage = clutter_stage_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Rectangle with rounded corners");
clutter_actor_set_background_color (stage, CLUTTER_COLOR_Black);
clutter_actor_set_size (stage, 500, 500);
clutter_actor_show (stage);
/* our 2D canvas, courtesy of Cairo */
canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300);
/* the actor that will display the contents of the canvas */
actor = clutter_actor_new ();
clutter_actor_set_content (actor, canvas);
clutter_actor_set_content_gravity (actor, CLUTTER_CONTENT_GRAVITY_CENTER);
clutter_actor_set_content_scaling_filters (actor,
CLUTTER_SCALING_FILTER_TRILINEAR,
CLUTTER_SCALING_FILTER_LINEAR);
clutter_actor_set_pivot_point (actor, 0.5f, 0.5f);
clutter_actor_add_constraint (actor, clutter_align_constraint_new (stage, CLUTTER_ALIGN_BOTH, 0.5));
clutter_actor_set_request_mode (actor, CLUTTER_REQUEST_CONTENT_SIZE);
clutter_actor_add_child (stage, actor);
/* the actor now owns the canvas */
g_object_unref (canvas);
/* create the continuous animation of the actor spinning around its center */
transition = clutter_property_transition_new ("rotation-angle-y");
clutter_transition_set_from (transition, G_TYPE_DOUBLE, 0.0);
clutter_transition_set_to (transition, G_TYPE_DOUBLE, 360.0);
clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 2000);
clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), -1);
clutter_actor_add_transition (actor, "rotateActor", transition);
/* the actor now owns the transition */
g_object_unref (transition);
/* quit on destroy */
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* connect our drawing code */
g_signal_connect (canvas, "draw", G_CALLBACK (draw_content), NULL);
/* invalidate the canvas, so that we can draw before the main loop starts */
clutter_content_invalidate (canvas);
clutter_main ();
return EXIT_SUCCESS;
}
/* Create actor for window but respect window stacking when adding */
static ClutterActor* _xfdashboard_live_workspace_create_and_add_window_actor(XfdashboardLiveWorkspace *self,
XfdashboardWindowTrackerWindow *inWindow)
{
XfdashboardLiveWorkspacePrivate *priv;
ClutterActor *actor;
ClutterContent *content;
GList *windows;
ClutterActor *lastWindowActor;
XfdashboardWindowTrackerWindow *window;
g_return_val_if_fail(XFDASHBOARD_IS_LIVE_WORKSPACE(self), NULL);
g_return_val_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_WINDOW(inWindow), NULL);
priv=self->priv;
/* We cannot assume that each window newly opened or moved to this workspace
* will be on top of all other windows. We need to respect window stacking.
* Therefore we iterate through list of windows in stacking order and find
* the last window we have an actor for before we the window requested.
*/
lastWindowActor=NULL;
windows=xfdashboard_window_tracker_get_windows_stacked(priv->windowTracker);
for( ; windows; windows=g_list_next(windows))
{
/* Get window from list */
window=XFDASHBOARD_WINDOW_TRACKER_WINDOW(windows->data);
if(!window) continue;
/* We do not need to check if window would be visible on this workspace
* as it should not have been created if it is not visible.
*/
lastWindowActor=_xfdashboard_live_workspace_find_by_window(self, window);
if(lastWindowActor) break;
}
/* Check if we have to "move" an existing window actor or if we have to create
* a new actor for window
*/
actor=_xfdashboard_live_workspace_find_by_window(self, inWindow);
if(actor)
{
/* Move existing window actor to new stacking position */
g_object_ref(actor);
clutter_actor_remove_child(CLUTTER_ACTOR(self), actor);
clutter_actor_insert_child_above(CLUTTER_ACTOR(self), actor, lastWindowActor);
g_object_unref(actor);
}
else
{
/* Create actor */
actor=clutter_actor_new();
content=xfdashboard_window_content_new_for_window(inWindow);
clutter_actor_set_content(actor, content);
g_object_unref(content);
/* Add new actor at right stacking position */
clutter_actor_insert_child_above(CLUTTER_ACTOR(self), actor, lastWindowActor);
}
return(actor);
}
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_new ();
clutter_stage_set_title (CLUTTER_STAGE (stage), "Kinect Test");
clutter_actor_set_size (stage, width * 2, height + 250);
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_actor_new ();
depth_canvas = clutter_canvas_new ();
clutter_actor_set_content (depth_tex, depth_canvas);
clutter_canvas_set_size (CLUTTER_CANVAS (depth_canvas), width, height);
clutter_actor_set_size (depth_tex, width, height);
clutter_actor_add_child (stage, depth_tex);
video_tex = clutter_actor_new ();
clutter_actor_set_content (video_tex, clutter_image_new ());
clutter_actor_set_size (video_tex, width, height);
clutter_actor_set_position (video_tex, width, 0.0);
clutter_actor_add_child (stage, video_tex);
info_text = clutter_text_new ();
clutter_actor_set_position (info_text, 50, height + 20);
clutter_actor_add_child (stage, info_text);
instructions = create_instructions ();
clutter_actor_set_position (instructions, 50, height + 70);
clutter_actor_add_child (stage, instructions);
skeleton = skeltrack_skeleton_new ();
g_object_get (skeleton, "smoothing-factor", &SMOOTHING_FACTOR, NULL);
set_info_text ();
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_canvas,
"draw",
G_CALLBACK (on_skeleton_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);
clutter_actor_show (stage);
}
static void
image_rendered_cb (GInputStream *stream, GAsyncResult *res, RendererData *data)
{
ChamplainTile *tile = data->tile;
gboolean error = TRUE;
GError *gerror = NULL;
ClutterActor *actor = NULL;
GdkPixbuf *pixbuf;
ClutterContent *content;
gfloat width, height;
pixbuf = gdk_pixbuf_new_from_stream_finish (res, NULL);
if (!pixbuf)
{
g_warning ("NULL pixbuf");
goto finish;
}
/* Load the image into clutter */
content = clutter_image_new ();
if (!clutter_image_set_data (CLUTTER_IMAGE (content),
gdk_pixbuf_get_pixels (pixbuf),
gdk_pixbuf_get_has_alpha (pixbuf)
? COGL_PIXEL_FORMAT_RGBA_8888
: COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
&gerror))
{
if (gerror)
{
g_warning ("Unable to transfer to clutter: %s", gerror->message);
g_error_free (gerror);
}
g_object_unref (content);
goto finish;
}
clutter_content_get_preferred_size (content, &width, &height);
actor = clutter_actor_new ();
clutter_actor_set_size (actor, width, height);
clutter_actor_set_content (actor, content);
g_object_unref (content);
/* has to be set for proper opacity */
clutter_actor_set_offscreen_redirect (actor, CLUTTER_OFFSCREEN_REDIRECT_AUTOMATIC_FOR_OPACITY);
error = FALSE;
finish:
if (actor)
champlain_tile_set_content (tile, actor);
g_signal_emit_by_name (tile, "render-complete", data->data, data->size, error);
if (pixbuf)
g_object_unref (pixbuf);
g_object_unref (data->renderer);
g_object_unref (tile);
g_object_unref (stream);
g_free (data->data);
g_slice_free (RendererData, data);
}
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);
}
Animation::Animation(ClutterActor *stage, TCLControl *tcl) {
printf("Building animation tools...\n");
//====================
// On screen display:
// Build the Actor that will display what's going to the lights:
lightDisplay = clutter_actor_new();
// Build the color delegate for the lightDisplay's content/texture:
colors = clutter_image_new();
// Error object for GDK/Clutter calls that need them
error = NULL;
// Load image data from some other data source...:
// guchar *data =
// GdkPixbuf *pixbuf = gdk_pixbuf_new_from_data(data);
// Load image data from a file:
// const char *img_path = "./wut.png";
// GdkPixbuf *pixbuf = gdk_pixbuf_new_from_file_at_size (img_path, WIDTH, HEIGHT, &error);
// Build the color buffer we'll store the actual colors in:
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, WIDTH, HEIGHT);
pixels = gdk_pixbuf_get_pixels(pixbuf); // Grab it's pixels...
rowstride = gdk_pixbuf_get_rowstride(pixbuf); // figure out the width of the buffer...
// And put some RED into the buffer to start off with
for (int x = 0; x < WIDTH; x++) {
for (int y = 0; y < HEIGHT; y++) {
// Find the ADDRESS of each pixel in the pixbuf via the raw char buffer we built...
// and bind it to a pointer to a char...
unsigned char *pixel = &pixels[y * rowstride + x * 3];
// And directly update that memory location with a new color
// This AUTOMATICALLY updates the color of the pixbuf!
// It's just hitting the memory directly!
pixel[0] = 255;//red
pixel[1] = 0x0;//green
pixel[2] = 0x0;//blue
}
}
// Dump the colors from the color buffer into the ClutterContent delegate!
if (pixbuf != NULL) {
clutter_image_set_data(CLUTTER_IMAGE(colors),
gdk_pixbuf_get_pixels (pixbuf),
COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
gdk_pixbuf_get_rowstride (pixbuf),
&error);
}
// Tell the lightDisplay that it's content should be whatever we've dumped in the content delegate:
clutter_actor_set_content(lightDisplay, colors);
// Define the size of the On Screen Display:
clutter_actor_set_x_expand(lightDisplay, TRUE);
clutter_actor_set_y_expand(lightDisplay, TRUE);
clutter_actor_set_position(lightDisplay, 0, WIDTH*(osd_scale+7)+WIDTH);
clutter_actor_set_size(lightDisplay, WIDTH, HEIGHT);
clutter_actor_set_scale(lightDisplay, osd_scale, osd_scale+7);
clutter_actor_set_rotation_angle(lightDisplay, CLUTTER_Z_AXIS, -90);
// Actually add that actor to the stage!
clutter_actor_add_child(stage, lightDisplay);
// Allow for UI events on this crazy thing!
clutter_actor_set_reactive(lightDisplay, TRUE);
// Wire up the event listener on this lightDisplay actor.
TouchData *touch_data;
touch_data = g_slice_new(TouchData); // reserve memory for it...
touch_data->lightDisplay = lightDisplay; // Place the button actor itself inside the struct
touch_data->tcl = tcl; // TCLControl *tcl is just a POINTER here (unlike in main.cpp)
touch_data->animationNumber = ¤tAnimation;
// Actually wire up the events and set up the data structs that the events need to operate:
g_signal_connect(lightDisplay, "touch-event", G_CALLBACK(handleTouchEvents), touch_data);
g_signal_connect(lightDisplay, "button-press-event", G_CALLBACK(handleTouchEvents), touch_data);
g_signal_connect(lightDisplay, "motion-event", G_CALLBACK(handleTouchEvents), touch_data);
g_signal_connect(lightDisplay, "button-release-event", G_CALLBACK(handleTouchEvents), touch_data);
// Set sane default values for the initial touch location
input_y = 0;
input_x = 0;
// End On screen display
//=============================
// Shader setup and wirings:
// Build the Actor that the shader will dump to directly:
shaderOutput = clutter_actor_new();
clutter_actor_set_position(shaderOutput, 0, 0);
clutter_actor_set_size(shaderOutput, WIDTH-1, HEIGHT);
clutter_actor_set_rotation_angle(shaderOutput, CLUTTER_Z_AXIS, -90);
clutter_actor_set_rotation_angle(shaderOutput, CLUTTER_Y_AXIS, 180);
clutter_actor_add_child(stage, shaderOutput);
// Allocate the memory for the shader output buffer:
// Figure out how big our buffer needs to be. *4 because four bytes per pixel (r, g, b, a) in shader land
int shaderBufferSize = WIDTH * HEIGHT * 4;
shaderBuffer = (guint8 *) malloc(shaderBufferSize); // malloc the buffer!!
// Double check that we built the buffer correctly.
if (shaderBuffer == NULL) {
printf("OOPS! malloc error!\n");
} else {
// printf("We malloc'd %i bytes for your shaderBuffer. It points at: %p\n", shaderBufferSize, shaderBuffer);
// printf(" The Rowstride on the shaderBuffer is %i\n", rowstride);
}
// init shader TEXTURES!
// Populate the noiseImage:
// const char *textureFile = "images/text_noise.png";
// audiopixbuf = gdk_pixbuf_new_from_file (textureFile, NULL);
// Init the audioImage that will store the FFT output for attaching to the actor
error = NULL;
audioImage = clutter_image_new ();
audiopixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, WIDTH, HEIGHT );
audioPixels = gdk_pixbuf_get_pixels(audiopixbuf); // Grab it's pixels...
audioRowstride = gdk_pixbuf_get_rowstride(audiopixbuf); // figure out the width of the buffer...
// Populate the audioImage with no data so we have a fresh start:
for (int x = 0; x < WIDTH; x++) {
for (int y = 0; y < HEIGHT; y++) {
// Find the ADDRESS of each pixel in the pixbuf via the raw char buffer we built...
// and bind it to a pointer to a char...
unsigned char *pixel = &audioPixels[y * audioRowstride + x * 3];
// And directly update that memory location with a new color
// This AUTOMATICALLY updates the color of the pixbuf!
// It's just hitting the memory directly!
pixel[0] = getrand(0,255);//((int)(samples[x]*max)) & 0xff; // low bits...
pixel[1] = getrand(0,255);//((int)(samples[x]*max)) & 0xff00; // high bits.
pixel[2] = getrand(0,255); // some random value could be used for noise...
}
}
// Actually load our color onto the actor
clutter_image_set_data (CLUTTER_IMAGE (audioImage),
gdk_pixbuf_get_pixels (audiopixbuf),
COGL_PIXEL_FORMAT_RGB_888,
gdk_pixbuf_get_width (audiopixbuf),
gdk_pixbuf_get_height (audiopixbuf),
gdk_pixbuf_get_rowstride (audiopixbuf),
&error);
// g_object_unref (audiopixbuf); // we want to reuse this... don't dereference that memory yet...
clutter_actor_set_content (shaderOutput, audioImage);
//clutter_actor_set_content_gravity (shaderOutput, CLUTTER_CONTENT_GRAVITY_TOP_RIGHT);
// audioTexture[0] = 0.25;
// srand(time(NULL));
// for (i=0; i<noiseTextureSize; i++) {
// noiseTexture[i] = getrandf();
// }
// Make sure we don't have a current shader so we don't break the update loop:
shaderLoaded = false;
currentSpeed = 100;
// Once we have all that set up, we still need to START THE ACTUAL ANIMATION!!
// To do that, we'll need to use the event chain/callback system we have been using so far.
// Get ready to hand this display chunk in to the animation event:
AnimationData *data;
data = g_slice_new(AnimationData); // reserve memory for it...
data->tcl = tcl; // tcl is an pointer to the main TCLControl object.
data->animationNumber = ¤tAnimation;
data->animationObject = this;
// The clutter timeline object takes a "duration" in milliseconds...
timeline = clutter_timeline_new(1);
g_signal_connect(timeline, "new-frame", G_CALLBACK(handleNewFrame), data);
// which will just continue repeating:
clutter_timeline_set_repeat_count(timeline, -1);
// This actually starts the timeline animation!
clutter_timeline_start(timeline);
// Generate the list of known shaders:
buildShaderList();
// Load the first shader so we do not get a black screen:
currentShader = 0; // Set the inital shader to load (usually, first in the directory)
updateCurrentShader();
}
