static gboolean
invalidate_canvas (ChamplainPathLayer *layer)
{
ChamplainPathLayerPrivate *priv = layer->priv;
gfloat view_width, view_height;
gint map_width, map_height;
gint viewport_x, viewport_y;
gint anchor_x, anchor_y;
gfloat right_actor_width, right_actor_height;
gfloat left_actor_width, left_actor_height;
right_actor_width = 256;
right_actor_height = 256;
left_actor_width = 0;
left_actor_height = 0;
map_width = 256;
map_height = 256;
if (priv->view != NULL)
{
get_map_size (priv->view, &map_width, &map_height);
clutter_actor_get_size (CLUTTER_ACTOR (priv->view), &view_width, &view_height);
champlain_view_get_viewport_origin (priv->view, &viewport_x, &viewport_y);
champlain_view_get_viewport_anchor (priv->view, &anchor_x, &anchor_y);
right_actor_width = MIN (map_width - (viewport_x + anchor_x), (gint)view_width);
right_actor_height = MIN (map_height - (viewport_y + anchor_y), (gint)view_height);
left_actor_width = MIN (view_width - right_actor_width, map_width - right_actor_width);
left_actor_height = right_actor_height;
/* Ensure sizes are positive */
right_actor_width = MAX (0, right_actor_width);
right_actor_height = MAX (0, right_actor_height);
left_actor_width = MAX (0, left_actor_width);
left_actor_height = MAX (0, left_actor_height);
}
clutter_actor_set_size (priv->path_actor, map_width, map_height);
clutter_actor_set_size (priv->right_actor, right_actor_width, right_actor_height);
clutter_canvas_set_size (CLUTTER_CANVAS (priv->right_canvas), right_actor_width, right_actor_height);
clutter_content_invalidate (priv->right_canvas);
if (left_actor_width != 0)
{
clutter_actor_set_size (priv->left_actor, left_actor_width, left_actor_height);
clutter_canvas_set_size (CLUTTER_CANVAS (priv->left_canvas), left_actor_width, left_actor_height);
clutter_content_invalidate (priv->left_canvas);
}
priv->redraw_scheduled = FALSE;
return FALSE;
}
static void
notify_selected (GObject *gobject,
G_GNUC_UNUSED GParamSpec *pspec,
G_GNUC_UNUSED gpointer user_data)
{
clutter_content_invalidate (CHAMPLAIN_POINT (gobject)->priv->canvas);
}
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;
}
static void
clutter_canvas_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterCanvasPrivate *priv = CLUTTER_CANVAS (gobject)->priv;
switch (prop_id)
{
case PROP_WIDTH:
{
gint new_size = g_value_get_int (value);
if (priv->width != new_size)
{
priv->width = new_size;
clutter_content_invalidate (CLUTTER_CONTENT (gobject));
}
}
break;
case PROP_HEIGHT:
{
gint new_size = g_value_get_int (value);
if (priv->height != new_size)
{
priv->height = new_size;
clutter_content_invalidate (CLUTTER_CONTENT (gobject));
}
}
break;
case PROP_SCALE_FACTOR:
clutter_canvas_set_scale_factor (CLUTTER_CANVAS (gobject),
g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
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;
}
static void _set_highlight(MetaSwitcher* self, int id, gboolean highlight)
{
if (id < 0) return;
MetaSwitcherPrivate* priv = self->priv;
MetaWindow* window = g_ptr_array_index(priv->apps, id);
ClutterActor* win_actor = g_hash_table_lookup(priv->icons, window);
WindowPrivate* win_priv = get_window_private(CLUTTER_ACTOR(win_actor));
win_priv->highlight = highlight;
ClutterActor* bg = clutter_container_find_child_by_name(CLUTTER_CONTAINER(win_actor), "bg");
clutter_content_invalidate(clutter_actor_get_content(bg));
}
/**
* champlain_point_set_size:
* @point: a #ChamplainPoint
* @size: The size of the point.
*
* Set the size of the point.
*
* Since: 0.10
*/
void
champlain_point_set_size (ChamplainPoint *point,
gdouble size)
{
g_return_if_fail (CHAMPLAIN_IS_POINT (point));
ChamplainPointPrivate *priv = point->priv;
point->priv->size = size;
clutter_canvas_set_size (CLUTTER_CANVAS (priv->canvas), size, size);
clutter_actor_set_size (CLUTTER_ACTOR (point), priv->size, priv->size);
clutter_actor_set_translation (CLUTTER_ACTOR (point), -priv->size/2, -priv->size/2, 0.0);
g_object_notify (G_OBJECT (point), "size");
clutter_content_invalidate (priv->canvas);
}
void
bacon_video_osd_actor_set_content (BaconVideoOsdActor *osd,
const char *icon_name,
const char *message)
{
g_return_if_fail (BACON_IS_VIDEO_OSD_ACTOR (osd));
g_free (osd->priv->icon_name);
osd->priv->icon_name = g_strdup (icon_name);
g_free (osd->priv->message);
osd->priv->message = g_strdup (message);
if (icon_name != NULL || message != NULL)
clutter_content_invalidate (CLUTTER_CONTENT (osd->priv->canvas));
}
/**
* champlain_point_set_color:
* @point: a #ChamplainPoint
* @color: (allow-none): The color of the point or NULL to reset the background to the
* default color. The color parameter is copied.
*
* Set the color of the point.
*
* Since: 0.10
*/
void
champlain_point_set_color (ChamplainPoint *point,
const ClutterColor *color)
{
g_return_if_fail (CHAMPLAIN_IS_POINT (point));
ChamplainPointPrivate *priv = point->priv;
if (priv->color != NULL)
clutter_color_free (priv->color);
if (color == NULL)
color = &DEFAULT_COLOR;
priv->color = clutter_color_copy (color);
g_object_notify (G_OBJECT (point), "color");
clutter_content_invalidate (priv->canvas);
}
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
on_track_joints (GObject *obj,
GAsyncResult *res,
gpointer user_data)
{
guint i;
BufferInfo *buffer_info;
guint16 *reduced;
gint width, height, reduced_width, reduced_height;
ClutterContent *content;
GError *error = NULL;
buffer_info = (BufferInfo *) user_data;
reduced = (guint16 *) buffer_info->reduced_buffer;
width = buffer_info->width;
height = buffer_info->height;
reduced_width = buffer_info->reduced_width;
reduced_height = buffer_info->reduced_height;
list = skeltrack_skeleton_track_joints_finish (skeleton,
res,
&error);
if (error == NULL)
{
if (SHOW_SKELETON)
{
content = clutter_actor_get_content (depth_tex);
clutter_content_invalidate (content);
}
}
else
{
g_warning ("%s\n", error->message);
g_error_free (error);
}
g_slice_free1 (reduced_width * reduced_height * sizeof (guint16), reduced);
g_slice_free (BufferInfo, buffer_info);
skeltrack_joint_list_free (list);
}
/**
* clutter_image_set_bytes:
* @image: a #ClutterImage
* @data: the image data, as a #GBytes
* @pixel_format: the Cogl pixel format of the image data
* @width: the width of the image data
* @height: the height of the image data
* @row_stride: the length of each row inside @data
* @error: return location for a #GError, or %NULL
*
* Sets the image data stored inside a #GBytes to be displayed by @image.
*
* If the image data was successfully loaded, the @image will be invalidated.
*
* In case of error, the @error value will be set, and this function will
* return %FALSE.
*
* The image data contained inside the #GBytes is copied in texture memory,
* and no additional reference is acquired on the @data.
*
* Return value: %TRUE if the image data was successfully loaded,
* and %FALSE otherwise.
*
* Since: 1.12
*/
gboolean
clutter_image_set_bytes (ClutterImage *image,
GBytes *data,
CoglPixelFormat pixel_format,
guint width,
guint height,
guint row_stride,
GError **error)
{
ClutterImagePrivate *priv;
CoglTextureFlags flags;
g_return_val_if_fail (CLUTTER_IS_IMAGE (image), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
priv = image->priv;
if (priv->texture != NULL)
cogl_object_unref (priv->texture);
flags = COGL_TEXTURE_NONE;
if (width >= 512 && height >= 512)
flags |= COGL_TEXTURE_NO_ATLAS;
priv->texture = cogl_texture_new_from_data (width, height,
flags,
pixel_format,
COGL_PIXEL_FORMAT_ANY,
row_stride,
g_bytes_get_data (data, NULL));
if (priv->texture == NULL)
{
g_set_error_literal (error, CLUTTER_IMAGE_ERROR,
CLUTTER_IMAGE_ERROR_INVALID_DATA,
_("Unable to load image data"));
return FALSE;
}
clutter_content_invalidate (CLUTTER_CONTENT (image));
return TRUE;
}
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);
}
gboolean meta_switcher_show(MetaSwitcher* self)
{
MetaSwitcherPrivate* priv = self->priv;
int screen_width, screen_height;
MetaScreen* screen = meta_plugin_get_screen(priv->plugin);
priv->workspace = meta_screen_get_active_workspace(screen);
meta_screen_get_size(screen, &screen_width, &screen_height);
meta_switcher_present_list(self);
if (priv->apps == NULL || priv->apps->len == 0) goto _end;
_capture_desktop(self);
clutter_content_invalidate(clutter_actor_get_content(priv->top));
ClutterActor* stage = meta_get_stage_for_screen(screen);
clutter_actor_insert_child_above(stage, priv->top, NULL);
clutter_actor_show(priv->top);
if (!meta_plugin_begin_modal(priv->plugin, 0, clutter_get_current_event_time())) {
if (!meta_plugin_begin_modal(priv->plugin, META_MODAL_POINTER_ALREADY_GRABBED,
clutter_get_current_event_time())) {
g_warning("can not be modal");
goto _end;
}
}
meta_disable_unredirect_for_screen(screen);
priv->modaled = TRUE;
priv->previous_focused = clutter_stage_get_key_focus(CLUTTER_STAGE(stage));
if (priv->previous_focused == stage) priv->previous_focused = NULL;
clutter_stage_set_key_focus(CLUTTER_STAGE(stage), priv->top);
clutter_actor_grab_key_focus(priv->top);
return TRUE;
_end:
clutter_actor_hide(priv->top);
return FALSE;
}
static gboolean
clutter_canvas_invalidate_internal (ClutterCanvas *canvas,
int width,
int height)
{
gboolean width_changed = FALSE, height_changed = FALSE;
gboolean res = FALSE;
GObject *obj;
obj = G_OBJECT (canvas);
g_object_freeze_notify (obj);
if (canvas->priv->width != width)
{
canvas->priv->width = width;
width_changed = TRUE;
g_object_notify_by_pspec (obj, obj_props[PROP_WIDTH]);
}
if (canvas->priv->height != height)
{
canvas->priv->height = height;
height_changed = TRUE;
g_object_notify_by_pspec (obj, obj_props[PROP_HEIGHT]);
}
if (width_changed || height_changed)
{
clutter_content_invalidate (CLUTTER_CONTENT (canvas));
res = TRUE;
}
g_object_thaw_notify (obj);
return res;
}
//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);
}
/**
* clutter_canvas_set_scale_factor:
* @canvas: a #ClutterCanvas
* @scale: the scale factor, or -1 for the default
*
* Sets the scaling factor for the Cairo surface used by @canvas.
*
* This function should rarely be used.
*
* The default scaling factor of a #ClutterCanvas content uses the
* #ClutterSettings:window-scaling-factor property, which is set by
* the windowing system. By using this function it is possible to
* override that setting.
*
* Changing the scale factor will invalidate the @canvas.
*
* Since: 1.18
*/
void
clutter_canvas_set_scale_factor (ClutterCanvas *canvas,
int scale)
{
ClutterCanvasPrivate *priv;
GObject *obj;
g_return_if_fail (CLUTTER_IS_CANVAS (canvas));
g_return_if_fail (scale != 0);
priv = canvas->priv;
if (scale < 0)
{
if (!priv->scale_factor_set)
return;
priv->scale_factor_set = FALSE;
priv->scale_factor = -1;
}
else
{
if (priv->scale_factor_set && priv->scale_factor == scale)
return;
priv->scale_factor_set = TRUE;
priv->scale_factor = scale;
}
clutter_content_invalidate (CLUTTER_CONTENT (canvas));
obj = G_OBJECT (canvas);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_FACTOR]);
g_object_notify_by_pspec (obj, obj_props[PROP_SCALE_FACTOR_SET]);
}
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;
}
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);
}
/**
* clutter_image_set_area:
* @image: a #ClutterImage
* @data: (array): the image data, as an array of bytes
* @pixel_format: the Cogl pixel format of the image data
* @rect: a rectangle indicating the area that should be set
* @row_stride: the length of each row inside @data
* @error: return location for a #GError, or %NULL
*
* Sets the image data to be display by @image, using @rect to indicate
* the position and size of the image data to be set.
*
* If the @image does not have any image data set when this function is
* called, a new texture will be created with the size of the width and
* height of the rectangle, i.e. calling this function on a newly created
* #ClutterImage will be the equivalent of calling clutter_image_set_data().
*
* If the image data was successfully loaded, the @image will be invalidated.
*
* In case of error, the @error value will be set, and this function will
* return %FALSE.
*
* The image data is copied in texture memory.
*
* Return value: %TRUE if the image data was successfully loaded,
* and %FALSE otherwise.
*
* Since: 1.10
*/
gboolean
clutter_image_set_area (ClutterImage *image,
const guint8 *data,
CoglPixelFormat pixel_format,
const cairo_rectangle_int_t *area,
guint row_stride,
GError **error)
{
ClutterImagePrivate *priv;
g_return_val_if_fail (CLUTTER_IS_IMAGE (image), FALSE);
g_return_val_if_fail (data != NULL, FALSE);
g_return_val_if_fail (area != NULL, FALSE);
priv = image->priv;
if (priv->texture == NULL)
{
CoglTextureFlags flags = COGL_TEXTURE_NONE;
if (area->width >= 512 && area->height >= 512)
flags |= COGL_TEXTURE_NO_ATLAS;
priv->texture = cogl_texture_new_from_data (area->width,
area->height,
flags,
pixel_format,
COGL_PIXEL_FORMAT_ANY,
row_stride,
data);
}
else
{
gboolean res;
res = cogl_texture_set_region (priv->texture,
0, 0,
area->x, area->y,
area->width, area->height,
area->width, area->height,
pixel_format,
row_stride,
data);
if (!res)
{
cogl_object_unref (priv->texture);
priv->texture = NULL;
}
}
if (priv->texture == NULL)
{
g_set_error_literal (error, CLUTTER_IMAGE_ERROR,
CLUTTER_IMAGE_ERROR_INVALID_DATA,
_("Unable to load image data"));
return FALSE;
}
clutter_content_invalidate (CLUTTER_CONTENT (image));
return TRUE;
}
int
main (int argc,
char *argv[])
{
ClutterActor *actor, *stage, *buttons, *button;
ChamplainMarkerLayer *layer;
ChamplainPathLayer *path;
gfloat width, total_width = 0;
if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
return 1;
stage = clutter_stage_new ();
clutter_actor_set_size (stage, 800, 600);
g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
/* Create the map view */
actor = champlain_view_new ();
clutter_actor_set_size (CLUTTER_ACTOR (actor), 800, 600);
clutter_actor_add_child (stage, actor);
/* Create the buttons */
buttons = clutter_actor_new ();
clutter_actor_set_position (buttons, PADDING, PADDING);
button = make_button ("Zoom in");
clutter_actor_add_child (buttons, button);
clutter_actor_set_reactive (button, TRUE);
clutter_actor_get_size (button, &width, NULL);
total_width += width + PADDING;
g_signal_connect (button, "button-release-event",
G_CALLBACK (zoom_in),
actor);
button = make_button ("Zoom out");
clutter_actor_add_child (buttons, button);
clutter_actor_set_reactive (button, TRUE);
clutter_actor_set_position (button, total_width, 0);
clutter_actor_get_size (button, &width, NULL);
g_signal_connect (button, "button-release-event",
G_CALLBACK (zoom_out),
actor);
clutter_actor_add_child (stage, buttons);
ClutterContent *canvas;
canvas = clutter_canvas_new ();
clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 512, 256);
g_signal_connect (canvas, "draw", G_CALLBACK (draw_background_tile), NULL);
clutter_content_invalidate (canvas);
champlain_view_set_background_pattern (CHAMPLAIN_VIEW (actor), canvas);
/* Create the markers and marker layer */
layer = create_marker_layer (CHAMPLAIN_VIEW (actor), &path);
champlain_view_add_layer (CHAMPLAIN_VIEW (actor), CHAMPLAIN_LAYER (layer));
/* Connect to the click event */
clutter_actor_set_reactive (actor, TRUE);
g_signal_connect (actor, "button-release-event",
G_CALLBACK (map_view_button_release_cb),
actor);
/* Finish initialising the map view */
g_object_set (G_OBJECT (actor), "zoom-level", 12,
"kinetic-mode", TRUE, NULL);
champlain_view_center_on (CHAMPLAIN_VIEW (actor), 45.466, -73.75);
clutter_actor_show (stage);
clutter_main ();
return 0;
}
