static void actor_realize_not_recursive (void) { ClutterActor *actor, *group; ClutterActor *stage; stage = clutter_test_get_stage (); clutter_actor_show (stage); group = clutter_actor_new (); actor = clutter_actor_new (); clutter_actor_hide (group); /* don't show, so won't map */ clutter_actor_hide (actor); /* don't show, so won't map */ g_assert (!(CLUTTER_ACTOR_IS_REALIZED (group))); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); clutter_actor_add_child (stage, group); clutter_actor_add_child (group, actor); clutter_actor_realize (group); g_assert (CLUTTER_ACTOR_IS_REALIZED (group)); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group))); /* realizing group did not realize the child */ g_assert (!CLUTTER_ACTOR_IS_REALIZED (actor)); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor))); }
static ClutterActor * make_button (char *text) { ClutterActor *button, *button_bg, *button_text; ClutterColor white = { 0xff, 0xff, 0xff, 0xff }; ClutterColor black = { 0x00, 0x00, 0x00, 0xff }; gfloat width, height; button = clutter_actor_new (); button_bg = clutter_actor_new (); clutter_actor_set_background_color (button_bg, &white); clutter_actor_add_child (button, button_bg); clutter_actor_set_opacity (button_bg, 0xcc); button_text = clutter_text_new_full ("Sans 10", text, &black); clutter_actor_add_child (button, button_text); clutter_actor_get_size (button_text, &width, &height); clutter_actor_set_size (button_bg, width + PADDING * 2, height + PADDING * 2); clutter_actor_set_position (button_bg, 0, 0); clutter_actor_set_position (button_text, PADDING, PADDING); return button; }
void clutter_box2_d_tests_clutter_box2_dlayout_manager_tests_test_clutterbox2d_layout_manager_hello_world (ClutterBox2DTestsClutterBox2DLayoutManagerTests* self) { ClutterBox2DLayoutManager* manager = NULL; ClutterBox2DLayoutManager* _tmp0_ = NULL; ClutterActor* world = NULL; ClutterActor* _tmp1_ = NULL; ClutterActor* actor = NULL; ClutterActor* _tmp2_ = NULL; g_return_if_fail (self != NULL); _tmp0_ = clutter_box2_d_layout_manager_new (); g_object_ref_sink (_tmp0_); manager = _tmp0_; _tmp1_ = clutter_actor_new (); g_object_ref_sink (_tmp1_); world = _tmp1_; clutter_actor_set_layout_manager (world, (ClutterLayoutManager*) manager); _tmp2_ = clutter_actor_new (); g_object_ref_sink (_tmp2_); actor = _tmp2_; clutter_actor_set_size (actor, (gfloat) 150, (gfloat) 150); clutter_actor_set_position (actor, (gfloat) 100, (gfloat) 120); clutter_actor_add_child (world, actor); _g_object_unref0 (actor); _g_object_unref0 (world); _g_object_unref0 (manager); }
static void clone_no_map (void) { ClutterActor *stage; ClutterActor *group; ClutterActor *actor; ClutterActor *clone; stage = clutter_test_get_stage (); clutter_actor_show (stage); group = clutter_actor_new (); actor = clutter_actor_new (); clutter_actor_hide (group); clutter_actor_add_child (group, actor); clutter_actor_add_child (stage, group); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); clone = clutter_clone_new (group); clutter_actor_add_child (stage, clone); g_assert (CLUTTER_ACTOR_IS_MAPPED (clone)); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); clutter_actor_destroy (CLUTTER_ACTOR (clone)); clutter_actor_destroy (CLUTTER_ACTOR (group)); }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterAction *action1; ClutterAction *action2; ClutterActor *actor1; ClutterActor *actor2; if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS) return 1; stage = clutter_stage_new (); clutter_actor_set_size (stage, 400, 400); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL); actor1 = clutter_actor_new (); clutter_actor_set_name (actor1, "Red Button"); clutter_actor_set_background_color (actor1, CLUTTER_COLOR_Red); clutter_actor_set_size (actor1, 100, 100); clutter_actor_set_reactive (actor1, TRUE); clutter_actor_set_position (actor1, 50, 150); clutter_actor_add_child (stage, actor1); actor2 = clutter_actor_new (); clutter_actor_set_name (actor2, "Blue Button"); clutter_actor_set_background_color (actor2, CLUTTER_COLOR_Blue); clutter_actor_set_size (actor2, 100, 100); clutter_actor_set_position (actor2, 250, 150); clutter_actor_set_reactive (actor2, TRUE); clutter_actor_add_child (stage, actor2); action1 = clutter_click_action_new (); clutter_actor_add_action (actor1, action1); action2 = clutter_click_action_new (); clutter_actor_add_action (actor2, action2); g_signal_connect (action1, "clicked", G_CALLBACK (clicked_cb), NULL); g_signal_connect (action2, "clicked", G_CALLBACK (clicked_cb), NULL); clutter_actor_show (stage); clutter_main (); return EXIT_SUCCESS; }
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 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; }
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; }
void meta_compositor_flash_window (MetaCompositor *compositor, MetaWindow *window) { ClutterActor *window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window)); ClutterActor *flash; ClutterTransition *transition; flash = clutter_actor_new (); clutter_actor_set_background_color (flash, CLUTTER_COLOR_Black); clutter_actor_set_size (flash, window->rect.width, window->rect.height); clutter_actor_set_position (flash, window->custom_frame_extents.left, window->custom_frame_extents.top); clutter_actor_set_opacity (flash, 0); clutter_actor_add_child (window_actor, flash); clutter_actor_save_easing_state (flash); clutter_actor_set_easing_mode (flash, CLUTTER_EASE_IN_QUAD); clutter_actor_set_easing_duration (flash, FLASH_TIME_MS); clutter_actor_set_opacity (flash, 192); transition = clutter_actor_get_transition (flash, "opacity"); clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE); clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2); g_signal_connect (transition, "stopped", G_CALLBACK (window_flash_out_completed), flash); clutter_actor_restore_easing_state (flash); }
static void on_drag_begin (ClutterDragAction *action, ClutterActor *actor, gfloat event_x, gfloat event_y, ClutterModifierType modifiers) { ClutterActor *handle; gfloat x_pos, y_pos; clutter_actor_get_position (actor, &x_pos, &y_pos); handle = clutter_actor_new (); clutter_actor_set_background_color (handle, CLUTTER_COLOR_DarkSkyBlue); clutter_actor_set_size (handle, 128, 128); clutter_actor_set_position (handle, event_x - x_pos, event_y - y_pos); clutter_actor_add_child (stage, handle); clutter_drag_action_set_drag_handle (action, handle); clutter_actor_save_easing_state (actor); clutter_actor_set_easing_mode (actor, CLUTTER_LINEAR); clutter_actor_set_opacity (actor, 128); clutter_actor_restore_easing_state (actor); drop_successful = FALSE; }
/** * st_texture_cache_load_sliced_image: * @cache: A #StTextureCache * @path: Path to a filename * @grid_width: Width in pixels * @grid_height: Height in pixels * * This function reads a single image file which contains multiple images internally. * The image file will be divided using @grid_width and @grid_height; * note that the dimensions of the image loaded from @path * should be a multiple of the specified grid dimensions. * * Returns: (transfer none): A new #ClutterActor */ ClutterActor * st_texture_cache_load_sliced_image (StTextureCache *cache, const gchar *path, gint grid_width, gint grid_height) { AsyncImageData *data; GSimpleAsyncResult *result; ClutterActor *actor = clutter_actor_new (); data = g_new0 (AsyncImageData, 1); data->grid_width = grid_width; data->grid_height = grid_height; data->path = g_strdup (path); data->actor = actor; g_object_ref (G_OBJECT (actor)); result = g_simple_async_result_new (G_OBJECT (cache), on_sliced_image_loaded, data, st_texture_cache_load_sliced_image); g_object_set_data_full (G_OBJECT (result), "load_sliced_image", data, on_data_destroy); g_simple_async_result_run_in_thread (result, load_sliced_image, G_PRIORITY_DEFAULT, NULL); g_object_unref (result); return actor; }
/** * st_texture_cache_load_sliced_image: * @cache: A #StTextureCache * @file: A #GFile * @grid_width: Width in pixels * @grid_height: Height in pixels * @scale: Scale factor of the display * @load_callback: (scope async) (nullable): Function called when the image is loaded, or %NULL * @user_data: Data to pass to the load callback * * This function reads a single image file which contains multiple images internally. * The image file will be divided using @grid_width and @grid_height; * note that the dimensions of the image loaded from @path * should be a multiple of the specified grid dimensions. * * Returns: (transfer none): A new #ClutterActor */ ClutterActor * st_texture_cache_load_sliced_image (StTextureCache *cache, GFile *file, gint grid_width, gint grid_height, gint scale, GFunc load_callback, gpointer user_data) { AsyncImageData *data; GTask *result; ClutterActor *actor = clutter_actor_new (); data = g_new0 (AsyncImageData, 1); data->grid_width = grid_width; data->grid_height = grid_height; data->scale_factor = scale; data->gfile = g_object_ref (file); data->actor = actor; data->load_callback = load_callback; data->load_callback_data = user_data; g_object_ref (G_OBJECT (actor)); result = g_task_new (cache, NULL, on_sliced_image_loaded, data); g_task_set_task_data (result, data, on_data_destroy); g_task_run_in_thread (result, load_sliced_image); g_object_unref (result); return actor; }
/** * st_texture_cache_load_sliced_image: * @cache: A #StTextureCache * @file: A #GFile * @grid_width: Width in pixels * @grid_height: Height in pixels * @scale: Scale factor of the display * @load_callback: (scope async) (nullable): Function called when the image is loaded, or %NULL * @user_data: Data to pass to the load callback * * This function reads a single image file which contains multiple images internally. * The image file will be divided using @grid_width and @grid_height; * note that the dimensions of the image loaded from @path * should be a multiple of the specified grid dimensions. * * Returns: (transfer none): A new #ClutterActor */ ClutterActor * st_texture_cache_load_sliced_image (StTextureCache *cache, GFile *file, gint grid_width, gint grid_height, gint scale, GFunc load_callback, gpointer user_data) { AsyncImageData *data; GSimpleAsyncResult *result; ClutterActor *actor = clutter_actor_new (); data = g_new0 (AsyncImageData, 1); data->grid_width = grid_width; data->grid_height = grid_height; data->scale_factor = scale; data->gfile = g_object_ref (file); data->actor = actor; data->load_callback = load_callback; data->load_callback_data = user_data; g_object_ref (G_OBJECT (actor)); result = g_simple_async_result_new (G_OBJECT (cache), on_sliced_image_loaded, data, st_texture_cache_load_sliced_image); g_object_set_data_full (G_OBJECT (result), "load_sliced_image", data, on_data_destroy); g_simple_async_result_run_in_thread (result, load_sliced_image, G_PRIORITY_DEFAULT, NULL); g_object_unref (result); return actor; }
void meta_compositor_flash_screen (MetaCompositor *compositor, MetaScreen *screen) { ClutterActor *stage; ClutterActor *flash; ClutterTransition *transition; gfloat width, height; stage = meta_get_stage_for_screen (screen); clutter_actor_get_size (stage, &width, &height); flash = clutter_actor_new (); clutter_actor_set_background_color (flash, CLUTTER_COLOR_Black); clutter_actor_set_size (flash, width, height); clutter_actor_set_opacity (flash, 0); clutter_actor_add_child (stage, flash); clutter_actor_save_easing_state (flash); clutter_actor_set_easing_mode (flash, CLUTTER_EASE_IN_QUAD); clutter_actor_set_easing_duration (flash, FLASH_TIME_MS); clutter_actor_set_opacity (flash, 192); transition = clutter_actor_get_transition (flash, "opacity"); clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE); clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), 2); g_signal_connect (transition, "stopped", G_CALLBACK (flash_out_completed), flash); clutter_actor_restore_easing_state (flash); }
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 actor_map_recursive (void) { ClutterActor *actor, *group; ClutterActor *stage; stage = clutter_test_get_stage (); clutter_actor_show (stage); group = clutter_actor_new (); actor = clutter_actor_new (); clutter_actor_hide (group); /* hide at first */ clutter_actor_show (actor); /* show at first */ g_assert (!(CLUTTER_ACTOR_IS_REALIZED (group))); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group))); g_assert ((CLUTTER_ACTOR_IS_VISIBLE (actor))); clutter_actor_add_child (stage, group); clutter_actor_add_child (group, actor); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (group))); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group))); g_assert ((CLUTTER_ACTOR_IS_VISIBLE (actor))); /* show group, which should map and realize both * group and child. */ clutter_actor_show (group); g_assert (CLUTTER_ACTOR_IS_REALIZED (group)); g_assert (CLUTTER_ACTOR_IS_REALIZED (actor)); g_assert (CLUTTER_ACTOR_IS_MAPPED (group)); g_assert (CLUTTER_ACTOR_IS_MAPPED (actor)); g_assert (CLUTTER_ACTOR_IS_VISIBLE (group)); g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor)); }
static void add_drag_object (ClutterActor *target) { ClutterActor *parent; if (drag == NULL) { ClutterAction *action; drag = clutter_actor_new (); clutter_actor_set_background_color (drag, CLUTTER_COLOR_LightSkyBlue); clutter_actor_set_size (drag, HANDLE_SIZE, HANDLE_SIZE); clutter_actor_set_position (drag, (TARGET_SIZE - HANDLE_SIZE) / 2.0, (TARGET_SIZE - HANDLE_SIZE) / 2.0); clutter_actor_set_reactive (drag, TRUE); action = clutter_drag_action_new (); g_signal_connect (action, "drag-begin", G_CALLBACK (on_drag_begin), NULL); g_signal_connect (action, "drag-end", G_CALLBACK (on_drag_end), NULL); clutter_actor_add_action (drag, action); } parent = clutter_actor_get_parent (drag); if (parent == target) { clutter_actor_save_easing_state (target); clutter_actor_set_easing_mode (target, CLUTTER_LINEAR); clutter_actor_set_opacity (target, 255); clutter_actor_restore_easing_state (target); return; } g_object_ref (drag); if (parent != NULL && parent != stage) { clutter_actor_remove_child (parent, drag); clutter_actor_save_easing_state (parent); clutter_actor_set_easing_mode (parent, CLUTTER_LINEAR); clutter_actor_set_opacity (parent, 64); clutter_actor_restore_easing_state (parent); } clutter_actor_add_child (target, drag); clutter_actor_save_easing_state (target); clutter_actor_set_easing_mode (target, CLUTTER_LINEAR); clutter_actor_set_opacity (target, 255); clutter_actor_restore_easing_state (target); g_object_unref (drag); }
static void actor_visibility_not_recursive (void) { ClutterActor *actor, *group; ClutterActor *stage; stage = clutter_test_get_stage (); group = clutter_actor_new (); actor = clutter_actor_new (); clutter_actor_hide (group); /* don't show, so won't map */ clutter_actor_hide (actor); /* don't show, so won't map */ g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (stage))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (group))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor))); clutter_actor_add_child (stage, group); clutter_actor_add_child (group, actor); clutter_actor_show (actor); g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor)); g_assert (!CLUTTER_ACTOR_IS_VISIBLE (group)); g_assert (!CLUTTER_ACTOR_IS_VISIBLE (stage)); clutter_actor_show (stage); g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor)); g_assert (!CLUTTER_ACTOR_IS_VISIBLE (group)); g_assert (CLUTTER_ACTOR_IS_VISIBLE (stage)); clutter_actor_hide (actor); clutter_actor_hide (group); clutter_actor_hide (stage); g_assert (!CLUTTER_ACTOR_IS_VISIBLE (actor)); clutter_actor_show (stage); g_assert (!CLUTTER_ACTOR_IS_VISIBLE (actor)); }
static void slider_init(Slider *self) { SliderPrivate *priv; ClutterLayoutManager *layout; priv = self->priv = SLIDER_GET_PRIVATE(self); priv->pos = 0.5; layout = clutter_bin_layout_new( CLUTTER_BIN_ALIGNMENT_CENTER, CLUTTER_BIN_ALIGNMENT_CENTER); ClutterColor col = {127, 127, 127, 255}; priv->box = clutter_actor_new(); clutter_actor_set_background_color(priv->box, &col); clutter_actor_set_layout_manager(priv->box, layout); clutter_actor_set_reactive(CLUTTER_ACTOR(priv->box), TRUE); clutter_actor_add_child(CLUTTER_ACTOR(self), priv->box); col.red = 40; col.green = 40; col.blue = 70; priv->handle = clutter_actor_new(); clutter_actor_set_background_color(priv->handle, &col); clutter_actor_set_layout_manager(priv->handle, layout); clutter_actor_set_reactive(CLUTTER_ACTOR(priv->handle), TRUE); clutter_actor_add_child(CLUTTER_ACTOR(self), priv->handle); priv->track_clicked = clutter_click_action_new(); clutter_actor_add_action(CLUTTER_ACTOR(priv->box), priv->track_clicked); g_signal_connect( priv->track_clicked, "clicked", G_CALLBACK(slider_clicked), self); priv->handle_dragged = clutter_drag_action_new(); clutter_actor_add_action(CLUTTER_ACTOR(priv->handle), priv->handle_dragged); g_signal_connect( priv->handle_dragged, "drag-motion", G_CALLBACK(handle_dragged), self); g_signal_connect(priv->box, "scroll-event", G_CALLBACK(scrolled), self); g_signal_connect(priv->handle, "scroll-event", G_CALLBACK(scrolled), self); }
/* Gets the desired workspace and creates any workspaces * necessary before it. */ static ClutterActor * mnb_zones_preview_get_workspace_group (MnbZonesPreview *preview, gint workspace) { gint i; GList *w; ClutterActor *bin = NULL; MnbZonesPreviewPrivate *priv = preview->priv; for (w = priv->workspace_bins, i = 0; (i < workspace) && w; w = w->next, i++); if ((i == workspace) && w) return mnb_fancy_bin_get_child (MNB_FANCY_BIN (w->data)); for (; i <= workspace; i++) { ClutterActor *group; /* Create a workspace clone */ bin = mnb_fancy_bin_new (); group = clutter_actor_new (); /* Add background if it's set */ if (priv->workspace_bg) { ClutterActor *bg = clutter_clone_new (priv->workspace_bg); clutter_actor_set_size (bg, priv->width, priv->height); clutter_actor_add_child (CLUTTER_ACTOR (group), bg); } clutter_actor_set_clip (group, 0, 0, priv->width, priv->height); mnb_fancy_bin_set_child (MNB_FANCY_BIN (bin), group); clutter_actor_add_child(CLUTTER_ACTOR (preview), bin); /* This is a bit of a hack, depending on the fact that GList * doesn't change the beginning of the list when appending * (unless the list is NULL). */ priv->workspace_bins = g_list_append (priv->workspace_bins, bin); } return mnb_fancy_bin_get_child (MNB_FANCY_BIN (bin)); }
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; }
/* object init: create a private structure and pack * composed ClutterActors into it */ static void cb_button_init (CbButton *self) { CbButtonPrivate *priv; ClutterLayoutManager *layout; priv = self->priv = CB_BUTTON_GET_PRIVATE (self); clutter_actor_set_reactive (CLUTTER_ACTOR (self), TRUE); /* the only child of this actor is a ClutterBox with a * ClutterBinLayout: painting and allocation of the actor basically * involves painting and allocating this child box */ layout = clutter_bin_layout_new (CLUTTER_BIN_ALIGNMENT_CENTER, CLUTTER_BIN_ALIGNMENT_CENTER); priv->child = clutter_actor_new (); clutter_actor_set_layout_manager (priv->child, layout); /* set the parent of the ClutterBox to this instance */ clutter_actor_add_child (CLUTTER_ACTOR (self), priv->child); /* add text label to the button; see the ClutterText API docs * for more information about available properties */ priv->label = g_object_new (CLUTTER_TYPE_TEXT, "line-alignment", PANGO_ALIGN_CENTER, "ellipsize", PANGO_ELLIPSIZE_END, NULL); clutter_actor_add_child (priv->child, priv->label); /* add a ClutterClickAction on this actor, so we can proxy its * "clicked" signal into a signal from this actor */ priv->click_action = clutter_click_action_new (); clutter_actor_add_action (CLUTTER_ACTOR (self), priv->click_action); g_signal_connect (priv->click_action, "clicked", G_CALLBACK (cb_button_clicked), NULL); }
static void ntf_tray_constructed (GObject *object) { NtfTray *self = (NtfTray*) object; ClutterActor *actor = (ClutterActor*) self; NtfTrayPrivate *priv = self->priv; ClutterActor *button; if (G_OBJECT_CLASS (ntf_tray_parent_class)->constructed) G_OBJECT_CLASS (ntf_tray_parent_class)->constructed (object); priv->notifiers = clutter_actor_new (); clutter_actor_add_child(actor, priv->notifiers); /* 'Overflow' control */ priv->control = mx_table_new (); mx_stylable_set_style_class (MX_STYLABLE (priv->control), "notification-control"); #if 0 button = mx_button_new (); mx_button_set_label (MX_BUTTON (button), _("Dismiss All")); mx_table_add_actor (MX_TABLE (priv->control), button, 0, 1); g_signal_connect (button, "clicked", G_CALLBACK (ntf_tray_dismiss_all_cb), self); #endif //DV priv->control_text = mx_label_new (); mx_table_add_actor (MX_TABLE (priv->control), CLUTTER_ACTOR (priv->control_text), 0, 0); clutter_actor_set_width (priv->control, CLUSTER_WIDTH); clutter_actor_add_child(actor, priv->control); clutter_actor_hide (priv->control); clutter_actor_set_reactive (priv->notifiers, TRUE); clutter_actor_set_reactive (actor, TRUE); mnb_input_manager_push_actor (actor, MNB_INPUT_LAYER_TOP); }
static void test_window (void) { GsdOsdDrawContext ctx; ClutterActor *stage, *actor; ClutterContent *canvas; GtkWidgetPath *widget_path; /* create a resizable stage */ stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "OSD Test"); clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE); clutter_actor_set_background_color (stage, CLUTTER_COLOR_Red); clutter_actor_set_size (stage, 300, 300); clutter_actor_show (stage); /* box canvas */ canvas = clutter_canvas_new (); clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300); actor = clutter_actor_new (); clutter_actor_add_constraint (actor, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0)); clutter_actor_set_content (actor, canvas); g_object_unref (canvas); clutter_actor_add_child (stage, actor); memset (&ctx, 0, sizeof(ctx)); widget_path = gtk_widget_path_new (); gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW); ctx.style = gtk_style_context_new (); gtk_style_context_set_path (ctx.style, widget_path); ctx.direction = clutter_get_default_text_direction (); ctx.theme = gtk_icon_theme_get_default (); g_signal_connect (canvas, "draw", G_CALLBACK (draw_box), &ctx); clutter_content_invalidate (canvas); g_signal_connect (stage, "destroy", G_CALLBACK (gtk_main_quit), NULL); }
static void actor_realized (void) { ClutterActor *actor; ClutterActor *stage; stage = clutter_test_get_stage (); actor = clutter_actor_new (); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); clutter_actor_hide (actor); /* don't show, so won't map */ clutter_actor_add_child (stage, actor); clutter_actor_realize (actor); g_assert (CLUTTER_ACTOR_IS_REALIZED (actor)); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor))); }
static void actor_mapped (void) { ClutterActor *actor; ClutterActor *stage; stage = clutter_test_get_stage (); clutter_actor_show (stage); actor = clutter_actor_new (); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); clutter_actor_add_child (stage, actor); if (g_test_verbose ()) g_print ("adding to a container should map - " "visible: %s, realized: %s, mapped: %s\n", CLUTTER_ACTOR_IS_VISIBLE (actor) ? "yes" : "no", CLUTTER_ACTOR_IS_REALIZED (actor) ? "yes" : "no", CLUTTER_ACTOR_IS_MAPPED (actor) ? "yes" : "no"); g_assert (CLUTTER_ACTOR_IS_REALIZED (actor)); g_assert (CLUTTER_ACTOR_IS_MAPPED (actor)); g_assert (CLUTTER_ACTOR_IS_VISIBLE (actor)); clutter_actor_hide (actor); if (g_test_verbose ()) g_print ("hiding should unmap - " "visible: %s, realized: %s, mapped: %s\n", CLUTTER_ACTOR_IS_VISIBLE (actor) ? "yes" : "no", CLUTTER_ACTOR_IS_REALIZED (actor) ? "yes" : "no", CLUTTER_ACTOR_IS_MAPPED (actor) ? "yes" : "no"); g_assert (CLUTTER_ACTOR_IS_REALIZED (actor)); g_assert (!CLUTTER_ACTOR_IS_MAPPED (actor)); g_assert (!CLUTTER_ACTOR_IS_VISIBLE (actor)); }
static void meta_switcher_init(MetaSwitcher *self) { MetaSwitcherPrivate* priv = self->priv = meta_switcher_get_instance_private(self); priv->selected_id = -1; priv->top = clutter_actor_new(); ClutterLayoutManager* box = clutter_box_layout_new(); clutter_box_layout_set_use_animations(CLUTTER_BOX_LAYOUT(box), TRUE); clutter_box_layout_set_easing_duration(CLUTTER_BOX_LAYOUT(box), 200); clutter_box_layout_set_easing_mode(CLUTTER_BOX_LAYOUT(box), CLUTTER_LINEAR); g_object_set(box, "spacing", 10, NULL); clutter_actor_set_layout_manager(priv->top, box); g_object_connect(G_OBJECT(priv->top), "signal::destroy", _emit_destroy, self, NULL); g_object_connect(priv->top, "signal::button-press-event", on_button_press, self, "signal::key-press-event", on_key_press, self, "signal::key-release-event", on_key_release, self, "signal::captured-event", on_captured_event, self, NULL); clutter_actor_hide(priv->top); }
static void actor_initial_state (void) { ClutterActor *actor; actor = clutter_actor_new (); g_object_ref_sink (actor); g_object_add_weak_pointer (G_OBJECT (actor), (gpointer *) &actor); if (g_test_verbose ()) g_print ("initial state - visible: %s, realized: %s, mapped: %s\n", CLUTTER_ACTOR_IS_VISIBLE (actor) ? "yes" : "no", CLUTTER_ACTOR_IS_REALIZED (actor) ? "yes" : "no", CLUTTER_ACTOR_IS_MAPPED (actor) ? "yes" : "no"); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); g_assert (!(CLUTTER_ACTOR_IS_VISIBLE (actor))); clutter_actor_destroy (actor); g_assert (actor == NULL); }
static void gt_player_backend_gstreamer_clutter_init(GtPlayerBackendGstreamerClutter* self) { GtPlayerBackendGstreamerClutterPrivate* priv = gt_player_backend_gstreamer_clutter_get_instance_private(self); static const ClutterColor bg_colour = {0x00, 0x00, 0x00, 0x00}; MESSAGE("Init"); priv->widget = gtk_clutter_embed_new(); priv->stage = gtk_clutter_embed_get_stage(GTK_CLUTTER_EMBED(priv->widget)); priv->player = clutter_gst_playback_new(); priv->video_actor = clutter_actor_new(); priv->content = clutter_gst_aspectratio_new(); g_object_ref(priv->widget); g_object_set(priv->content, "player", priv->player, NULL); g_object_set(priv->video_actor, "content", priv->content, NULL); clutter_actor_add_child(priv->stage, priv->video_actor); clutter_actor_set_background_color(priv->stage, &bg_colour); /* clutter_gst_playback_set_buffering_mode(priv->player, CLUTTER_GST_BUFFERING_MODE_STREAM); // In-memory buffering (let user choose?) */ clutter_gst_playback_set_buffering_mode(priv->player, CLUTTER_GST_BUFFERING_MODE_DOWNLOAD); // On-disk buffering g_object_bind_property(self, "volume", priv->player, "audio-volume", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); g_object_bind_property(self, "uri", priv->player, "uri", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); g_object_bind_property(priv->player, "buffer-fill", self, "buffer-fill", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); g_signal_connect(priv->widget, "size-allocate", G_CALLBACK(size_allocate_cb), self); //TODO: Change this into a configure signal }