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; }