/* The value of a scrollbar has changed */ static void _xfdashboard_viewpad_on_scrollbar_value_changed(XfdashboardViewpad *self, gfloat inValue, gpointer inUserData) { XfdashboardViewpadPrivate *priv; ClutterActor *scrollbar; gfloat x, y, w, h; g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(self)); g_return_if_fail(XFDASHBOARD_IS_SCROLLBAR(inUserData)); priv=self->priv; scrollbar=CLUTTER_ACTOR(inUserData); /* Update clipping */ if(clutter_actor_has_clip(CLUTTER_ACTOR(priv->activeView))) { clutter_actor_get_clip(CLUTTER_ACTOR(priv->activeView), &x, &y, &w, &h); if(scrollbar==priv->hScrollbar) x=inValue; else if(scrollbar==priv->vScrollbar) y=inValue; } else { x=y=0.0f; clutter_actor_get_size(CLUTTER_ACTOR(priv->activeView), &w, &h); } clutter_actor_set_clip(CLUTTER_ACTOR(priv->activeView), x, y, w, h); /* Update viewport */ _xfdashboard_viewpad_update_view_viewport(self); }
G_MODULE_EXPORT int test_viewport_main (int argc, char *argv[]) { ClutterTimeline *timeline; ClutterAlpha *alpha; ClutterBehaviour *r_behave; ClutterActor *stage; ClutterActor *hand; ClutterColor stage_color = { 0xcc, 0xcc, 0xcc, 0xff }; gchar *file; clutter_init (&argc, &argv); stage = clutter_stage_get_default (); clutter_stage_set_color (CLUTTER_STAGE (stage), &stage_color); /* Make a hand */ file = g_build_filename (TESTS_DATADIR, "redhand.png", NULL); hand = clutter_texture_new_from_file (file, NULL); if (!hand) g_error("Unable to load image '%s'", file); g_free (file); clutter_actor_set_position (hand, 300, 200); clutter_actor_set_clip (hand, 20, 21, 132, 170); clutter_actor_set_anchor_point (hand, 86, 125); clutter_actor_show (hand); clutter_container_add_actor (CLUTTER_CONTAINER (stage), hand); /* Make a timeline */ timeline = clutter_timeline_new (7692); clutter_timeline_set_loop (timeline, TRUE); /* Set an alpha func to power behaviour */ alpha = clutter_alpha_new_full (timeline, CLUTTER_LINEAR); /* Create a behaviour for that alpha */ r_behave = clutter_behaviour_rotate_new (alpha, CLUTTER_Z_AXIS, CLUTTER_ROTATE_CW, 0.0, 360.0); /* Apply it to our actor */ clutter_behaviour_apply (r_behave, hand); /* start the timeline and thus the animations */ clutter_timeline_start (timeline); clutter_actor_show_all (stage); clutter_main(); g_object_unref (r_behave); return 0; }
IO_METHOD(IoClutterActor, setClip) { clutter_actor_set_clip( IOCACTOR(self), IoMessage_locals_floatArgAt_(m, locals, 0), IoMessage_locals_floatArgAt_(m, locals, 1), IoMessage_locals_floatArgAt_(m, locals, 2), IoMessage_locals_floatArgAt_(m, locals, 3) ); return self; }
static void rc_update_pixbuf(void *renderer, gboolean lazy) { RendererClutter *rc = (RendererClutter *)renderer; PixbufRenderer *pr = rc->pr; DEBUG_3("rc_update_pixbuf"); rc_remove_pending_updates(rc); rc->last_pixbuf_change = g_get_monotonic_time(); DEBUG_3("%s change time reset", get_exec_time()); if (pr->pixbuf) { gint width = gdk_pixbuf_get_width(pr->pixbuf); gint height = gdk_pixbuf_get_height(pr->pixbuf); DEBUG_3("pixbuf size %d x %d (%d)", width, height, gdk_pixbuf_get_has_alpha(pr->pixbuf) ? 32 : 24); gint prev_width, prev_height; if (pr->stereo_data == STEREO_PIXBUF_SBS || pr->stereo_data == STEREO_PIXBUF_CROSS) { width /= 2; } clutter_texture_get_base_size(CLUTTER_TEXTURE(rc->texture), &prev_width, &prev_height); if (width != prev_width || height != prev_height) { /* FIXME use CoglMaterial with multiple textures for background, color management, anaglyph, ... */ CoglHandle texture = cogl_texture_new_with_size(width, height, COGL_TEXTURE_NO_AUTO_MIPMAP | COGL_TEXTURE_NO_SLICING, gdk_pixbuf_get_has_alpha(pr->pixbuf) ? COGL_PIXEL_FORMAT_BGRA_8888 : COGL_PIXEL_FORMAT_BGR_888); if (texture != COGL_INVALID_HANDLE) { clutter_texture_set_cogl_texture(CLUTTER_TEXTURE(rc->texture), texture); cogl_handle_unref(texture); } } clutter_actor_set_clip(rc->texture, 0, 0, 0, 0); /* visible area is extended as area_changed events arrive */ if (!lazy) { rc_area_changed(renderer, GET_RIGHT_PIXBUF_OFFSET(rc), 0, width, height); } } rc->clut_updated = FALSE; }
/* 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)); }
/* Update view depending on scrollbar values */ static void _xfdashboard_viewpad_update_view_viewport(XfdashboardViewpad *self) { XfdashboardViewpadPrivate *priv; ClutterMatrix transform; gfloat x, y, w, h; g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(self)); priv=self->priv; /* Check for active view */ if(priv->activeView==NULL) { g_warning(_("Cannot update viewport of view because no one is active")); return; } /* Get offset from scrollbars and view size from clipping */ if(clutter_actor_has_clip(CLUTTER_ACTOR(priv->activeView))) { clutter_actor_get_clip(CLUTTER_ACTOR(priv->activeView), &x, &y, &w, &h); } else { x=y=0.0f; clutter_actor_get_size(CLUTTER_ACTOR(priv->activeView), &w, &h); } /* To avoid blur convert float to ints (virtually) */ x=ceil(x); y=ceil(y); w=ceil(w); h=ceil(h); /* Set transformation (offset) */ cogl_matrix_init_identity(&transform); cogl_matrix_translate(&transform, -x, -y, 0.0f); clutter_actor_set_transform(CLUTTER_ACTOR(priv->activeView), &transform); /* Set new clipping */ clutter_actor_set_clip(CLUTTER_ACTOR(priv->activeView), x, y, w, h); }
/* Scroll to requested position in view */ static void _xfdashboard_viewpad_on_view_scroll_to(XfdashboardViewpad *self, gfloat inX, gfloat inY, gpointer inUserData) { XfdashboardViewpadPrivate *priv; XfdashboardView *view; gfloat x, y, w, h; g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(self)); g_return_if_fail(XFDASHBOARD_IS_VIEW(inUserData)); priv=self->priv; view=XFDASHBOARD_VIEW(inUserData); /* If to-scroll view is the active view in viewpad * just set scrollbar value to the new ones */ if(view==priv->activeView) { if(inX>=0.0f) xfdashboard_scrollbar_set_value(XFDASHBOARD_SCROLLBAR(priv->hScrollbar), inX); if(inY>=0.0f) xfdashboard_scrollbar_set_value(XFDASHBOARD_SCROLLBAR(priv->vScrollbar), inY); } /* If to-scroll view is not the active one update its clipping */ else { if(clutter_actor_has_clip(CLUTTER_ACTOR(view))) { clutter_actor_get_clip(CLUTTER_ACTOR(view), &x, &y, &w, &h); if(inX>=0.0f) x=inX; if(inY>=0.0f) y=inY; } else { x=y=0.0f; clutter_actor_get_size(CLUTTER_ACTOR(view), &w, &h); } clutter_actor_set_clip(CLUTTER_ACTOR(view), x, y, w, h); } }
static void rc_area_clip_add(RendererClutter *rc, gfloat x, gfloat y, gfloat w, gfloat h) { gfloat x2, y2; gfloat clip_x, clip_y, clip_w, clip_h, clip_x2, clip_y2; x2 = x + w; y2 = y + h; clutter_actor_get_clip(rc->texture, &clip_x, &clip_y, &clip_w, &clip_h); clip_x2 = clip_x + clip_w; clip_y2 = clip_y + clip_h; if (clip_x > x) clip_x = x; if (clip_x2 < x2) clip_x2 = x2; if (clip_y > y) clip_y = y; if (clip_y2 < y2) clip_y2 = y2; clip_w = clip_x2 - clip_x; clip_h = clip_y2 - clip_y; clutter_actor_set_clip(rc->texture, clip_x, clip_y, clip_w, clip_h); }
static gboolean on_timeout (State *state) { int test_num = 0; int y, x; ClutterActor *over_actor = NULL; for (test_num = 0; test_num < 3; test_num++) { if (test_num == 0) { if (g_test_verbose ()) g_print ("No covering actor:\n"); } if (test_num == 1) { static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff }; /* Create an actor that covers the whole stage but that isn't visible so it shouldn't affect the picking */ over_actor = clutter_rectangle_new_with_color (&red); clutter_actor_set_size (over_actor, STAGE_WIDTH, STAGE_HEIGHT); clutter_container_add (CLUTTER_CONTAINER (state->stage), over_actor, NULL); clutter_actor_hide (over_actor); if (g_test_verbose ()) g_print ("Invisible covering actor:\n"); } else if (test_num == 2) { /* Make the actor visible but set a clip so that only some of the actors are accessible */ clutter_actor_show (over_actor); clutter_actor_set_clip (over_actor, state->actor_width * 2, state->actor_height * 2, state->actor_width * (ACTORS_X - 4), state->actor_height * (ACTORS_Y - 4)); if (g_test_verbose ()) g_print ("Clipped covering actor:\n"); } for (y = 0; y < ACTORS_Y; y++) for (x = 0; x < ACTORS_X; x++) { gboolean pass = FALSE; guint32 gid; ClutterActor *actor = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage), CLUTTER_PICK_ALL, x * state->actor_width + state->actor_width / 2, y * state->actor_height + state->actor_height / 2); if (g_test_verbose ()) g_print ("% 3i,% 3i / % 4i -> ", x, y, (int) state->gids[y * ACTORS_X + x]); if (actor == NULL) { if (g_test_verbose ()) g_print ("NULL: FAIL\n"); } else if (actor == over_actor) { if (test_num == 2 && x >= 2 && x < ACTORS_X - 2 && y >= 2 && y < ACTORS_Y - 2) pass = TRUE; if (g_test_verbose ()) g_print ("over_actor: %s\n", pass ? "pass" : "FAIL"); } else { gid = clutter_actor_get_gid (actor); if (gid == state->gids[y * ACTORS_X + x] && (test_num != 2 || x < 2 || x >= ACTORS_X - 2 || y < 2 || y >= ACTORS_Y - 2)) pass = TRUE; if (g_test_verbose ()) g_print ("% 10i: %s\n", gid, pass ? "pass" : "FAIL"); } if (!pass) state->pass = FALSE; } } clutter_main_quit (); return FALSE; }
/* Allocate position and size of actor and its children */ static void _xfdashboard_viewpad_allocate(ClutterActor *self, const ClutterActorBox *inBox, ClutterAllocationFlags inFlags) { XfdashboardViewpadPrivate *priv=XFDASHBOARD_VIEWPAD(self)->priv; ClutterActorClass *actorClass=CLUTTER_ACTOR_CLASS(xfdashboard_viewpad_parent_class); gfloat viewWidth, viewHeight; gfloat vScrollbarWidth, vScrollbarHeight; gfloat hScrollbarWidth, hScrollbarHeight; gboolean hScrollbarVisible, vScrollbarVisible; ClutterActorBox *box; gfloat x, y, w, h; /* Chain up to store the allocation of the actor */ if(actorClass->allocate) actorClass->allocate(self, inBox, inFlags); /* Initialize largest possible allocation for view and determine * real size of view to show. The real size is used to determine * scroll bar visibility if policy is automatic */ viewWidth=clutter_actor_box_get_width(inBox); viewHeight=clutter_actor_box_get_height(inBox); /* Determine visibility of scroll bars */ hScrollbarVisible=FALSE; if(priv->hScrollbarPolicy==XFDASHBOARD_POLICY_ALWAYS || (priv->hScrollbarPolicy==XFDASHBOARD_POLICY_AUTOMATIC && xfdashboard_scrollbar_get_range(XFDASHBOARD_SCROLLBAR(priv->hScrollbar))>viewWidth)) { hScrollbarVisible=TRUE; } if(xfdashboard_view_get_fit_mode(XFDASHBOARD_VIEW(priv->activeView))==XFDASHBOARD_FIT_MODE_HORIZONTAL || xfdashboard_view_get_fit_mode(XFDASHBOARD_VIEW(priv->activeView))==XFDASHBOARD_FIT_MODE_BOTH) { hScrollbarVisible=FALSE; } vScrollbarVisible=FALSE; if(priv->vScrollbarPolicy==XFDASHBOARD_POLICY_ALWAYS || (priv->vScrollbarPolicy==XFDASHBOARD_POLICY_AUTOMATIC && xfdashboard_scrollbar_get_range(XFDASHBOARD_SCROLLBAR(priv->vScrollbar))>viewHeight)) { vScrollbarVisible=TRUE; } if(xfdashboard_view_get_fit_mode(XFDASHBOARD_VIEW(priv->activeView))==XFDASHBOARD_FIT_MODE_VERTICAL || xfdashboard_view_get_fit_mode(XFDASHBOARD_VIEW(priv->activeView))==XFDASHBOARD_FIT_MODE_BOTH) { vScrollbarVisible=FALSE; } /* Set allocation for visible scroll bars */ vScrollbarWidth=0.0f; vScrollbarHeight=viewHeight; clutter_actor_get_preferred_width(priv->vScrollbar, -1, NULL, &vScrollbarWidth); hScrollbarWidth=viewWidth; hScrollbarHeight=0.0f; clutter_actor_get_preferred_height(priv->hScrollbar, -1, NULL, &hScrollbarHeight); if(hScrollbarVisible && vScrollbarVisible) { vScrollbarHeight-=hScrollbarHeight; hScrollbarWidth-=vScrollbarWidth; } if(vScrollbarVisible==FALSE) box=clutter_actor_box_new(0, 0, 0, 0); else box=clutter_actor_box_new(viewWidth-vScrollbarWidth, 0, viewWidth, vScrollbarHeight); clutter_actor_allocate(priv->vScrollbar, box, inFlags); clutter_actor_box_free(box); if(hScrollbarVisible==FALSE) box=clutter_actor_box_new(0, 0, 0, 0); else box=clutter_actor_box_new(0, viewHeight-hScrollbarHeight, hScrollbarWidth, viewHeight); clutter_actor_allocate(priv->hScrollbar, box, inFlags); clutter_actor_box_free(box); /* Reduce allocation for view by any visible scroll bar * and set allocation and clipping of view */ if(priv->activeView) { /* Set allocation */ if(vScrollbarVisible) viewWidth-=vScrollbarWidth; if(hScrollbarVisible) viewHeight-=hScrollbarHeight; x=y=0.0f; if(clutter_actor_has_clip(CLUTTER_ACTOR(priv->activeView))) { clutter_actor_get_clip(CLUTTER_ACTOR(priv->activeView), &x, &y, NULL, NULL); } switch(xfdashboard_view_get_fit_mode(XFDASHBOARD_VIEW(priv->activeView))) { case XFDASHBOARD_FIT_MODE_BOTH: w=viewWidth; h=viewHeight; break; case XFDASHBOARD_FIT_MODE_HORIZONTAL: w=viewWidth; clutter_actor_get_preferred_height(CLUTTER_ACTOR(priv->activeView), w, NULL, &h); break; case XFDASHBOARD_FIT_MODE_VERTICAL: h=viewHeight; clutter_actor_get_preferred_width(CLUTTER_ACTOR(priv->activeView), h, NULL, &w); break; default: clutter_actor_get_preferred_size(CLUTTER_ACTOR(priv->activeView), NULL, NULL, &w, &h); break; } box=clutter_actor_box_new(0, 0, w, h); clutter_actor_allocate(CLUTTER_ACTOR(priv->activeView), box, inFlags); clutter_actor_box_free(box); clutter_actor_set_clip(CLUTTER_ACTOR(priv->activeView), x, y, viewWidth, viewHeight); } /* Only set value if it changes */ if(priv->hScrollbarVisible!=hScrollbarVisible) { /* Set new value */ priv->hScrollbarVisible=hScrollbarVisible; /* Notify about property change */ g_object_notify_by_pspec(G_OBJECT(self), XfdashboardViewpadProperties[PROP_HSCROLLBAR_VISIBLE]); } if(priv->vScrollbarVisible!=vScrollbarVisible) { /* Set new value */ priv->vScrollbarVisible=vScrollbarVisible; /* Notify about property change */ g_object_notify_by_pspec(G_OBJECT(self), XfdashboardViewpadProperties[PROP_VSCROLLBAR_VISIBLE]); } }
static gboolean on_timeout (State *state) { int test_num = 0; int y, x; ClutterActor *over_actor = NULL; /* This will cause an unclipped pick redraw that will get buffered. We'll check below that this buffer is discarded because we also need to pick non-reactive actors */ clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage), CLUTTER_PICK_REACTIVE, 10, 10); clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage), CLUTTER_PICK_REACTIVE, 10, 10); for (test_num = 0; test_num < 5; test_num++) { if (test_num == 0) { if (g_test_verbose ()) g_print ("No covering actor:\n"); } if (test_num == 1) { static const ClutterColor red = { 0xff, 0x00, 0x00, 0xff }; /* Create an actor that covers the whole stage but that isn't visible so it shouldn't affect the picking */ over_actor = clutter_rectangle_new_with_color (&red); clutter_actor_set_size (over_actor, STAGE_WIDTH, STAGE_HEIGHT); clutter_container_add (CLUTTER_CONTAINER (state->stage), over_actor, NULL); clutter_actor_hide (over_actor); if (g_test_verbose ()) g_print ("Invisible covering actor:\n"); } else if (test_num == 2) { /* Make the actor visible but set a clip so that only some of the actors are accessible */ clutter_actor_show (over_actor); clutter_actor_set_clip (over_actor, state->actor_width * 2, state->actor_height * 2, state->actor_width * (ACTORS_X - 4), state->actor_height * (ACTORS_Y - 4)); if (g_test_verbose ()) g_print ("Clipped covering actor:\n"); } else if (test_num == 3) { clutter_actor_hide (over_actor); clutter_actor_add_effect_with_name (CLUTTER_ACTOR (state->stage), "blur", clutter_blur_effect_new ()); if (g_test_verbose ()) g_print ("With blur effect:\n"); } else if (test_num == 4) { clutter_actor_hide (over_actor); clutter_actor_remove_effect_by_name (CLUTTER_ACTOR (state->stage), "blur"); clutter_actor_add_effect_with_name (CLUTTER_ACTOR (state->stage), "shift", g_object_new (TYPE_SHIFT_EFFECT, NULL)); if (g_test_verbose ()) g_print ("With shift effect:\n"); } for (y = 0; y < ACTORS_Y; y++) { if (test_num == 4) x = 1; else x = 0; for (; x < ACTORS_X; x++) { gboolean pass = FALSE; gfloat pick_x; ClutterActor *actor; pick_x = x * state->actor_width + state->actor_width / 2; if (test_num == 4) pick_x -= SHIFT_STEP; actor = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (state->stage), CLUTTER_PICK_ALL, pick_x, y * state->actor_height + state->actor_height / 2); if (g_test_verbose ()) g_print ("% 3i,% 3i / %p -> ", x, y, state->actors[y * ACTORS_X + x]); if (actor == NULL) { if (g_test_verbose ()) g_print ("NULL: FAIL\n"); } else if (actor == over_actor) { if (test_num == 2 && x >= 2 && x < ACTORS_X - 2 && y >= 2 && y < ACTORS_Y - 2) pass = TRUE; if (g_test_verbose ()) g_print ("over_actor: %s\n", pass ? "pass" : "FAIL"); } else { if (actor == state->actors[y * ACTORS_X + x] && (test_num != 2 || x < 2 || x >= ACTORS_X - 2 || y < 2 || y >= ACTORS_Y - 2)) pass = TRUE; if (g_test_verbose ()) g_print ("%p: %s\n", actor, pass ? "pass" : "FAIL"); } if (!pass) state->pass = FALSE; } } } clutter_main_quit (); return FALSE; }
static void on_gesture_end(ClutterGestureAction *action, ClutterActor *stage, gpointer data) { ClutterActor *new_actor, *texture, *actor; gfloat x, y, w, h; GError *error = NULL; GdkColor color; guint16 alpha; gint iw = 125; gint ih = 126; gboolean repeat_x = FALSE; gboolean repeat_y = TRUE; guint bgr; new_actor = tmpRect; gtk_color_button_get_color(GTK_COLOR_BUTTON(app.colorpicker), &color); alpha = gtk_color_button_get_alpha(GTK_COLOR_BUTTON(app.colorpicker)); ClutterColor col = { CLAMP(((color.red / 65535.0) * 255), 0, 255), CLAMP(((color.green / 65535.0) * 255), 0, 255), CLAMP(((color.blue / 65535.0) * 255), 0, 255), CLAMP(((alpha / 65535.0) * 255), 0, 255), }; clutter_rectangle_set_color(CLUTTER_RECTANGLE(new_actor), &col); clutter_rectangle_set_border_width(CLUTTER_RECTANGLE(new_actor), 0); tmpRect = NULL; clutter_actor_get_position(new_actor, &x, &y); clutter_actor_get_size(new_actor, &w, &h); if (background_image_file != NULL){ texture = clutter_texture_new_from_file(background_image_file, &error); if (error != NULL){ g_print("Loading image failed\n"); g_error_free(error); } clutter_actor_set_position(texture, x, y); clutter_actor_set_size(texture, w, h); clutter_actor_add_child(stage, texture); clutter_actor_show(texture); bgr = gtk_combo_box_get_active(GTK_COMBO_BOX(app.background_repeat_select)); switch (bgr){ case 0: repeat_x = repeat_y = FALSE; break; case 1: repeat_x = TRUE; repeat_y = FALSE; break; case 2: repeat_x = FALSE; repeat_y = TRUE; break; case 3: repeat_x = repeat_y = TRUE; break; } clutter_texture_get_base_size(CLUTTER_TEXTURE(texture), &iw, &ih); clutter_actor_set_clip(texture, 0, 0, repeat_x ? w : iw, repeat_y ? h : ih); clutter_texture_set_sync_size(CLUTTER_TEXTURE(texture), TRUE); clutter_texture_set_repeat(CLUTTER_TEXTURE(texture), TRUE, TRUE); clutter_texture_set_keep_aspect_ratio(CLUTTER_TEXTURE(texture), TRUE); actor = texture; clutter_actor_destroy(new_actor); } else { actor = new_actor; } tool = TOOL_SELECT; clutter_actor_add_action(actor, clutter_drag_action_new()); clutter_actor_set_reactive(actor, TRUE); actors = g_list_append(actors, actor); GdkWindow *gdk_window; gdk_window = gtk_widget_get_window(app.stage); gdk_window_set_cursor(gdk_window, NULL); }
void test_texture_fbo (TestConformSimpleFixture *fixture, gconstpointer data) { TestState state; guint idle_source; gulong paint_handler; ClutterActor *actor; int ypos = 0; state.frame = 0; state.stage = clutter_stage_get_default (); clutter_stage_set_color (CLUTTER_STAGE (state.stage), &stage_color); /* Onscreen source with clone next to it */ actor = create_source (); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); clutter_actor_set_position (actor, 0, ypos * SOURCE_SIZE); actor = clutter_texture_new_from_actor (actor); clutter_actor_set_position (actor, SOURCE_SIZE, ypos * SOURCE_SIZE); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); ypos++; /* Offscreen source with clone */ #if 0 /* this doesn't work */ actor = create_source (); actor = clutter_texture_new_from_actor (actor); clutter_actor_set_position (actor, SOURCE_SIZE, ypos * SOURCE_SIZE); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); #endif ypos++; /* Source clipped to the top left division */ actor = create_source (); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); clutter_actor_set_position (actor, 0, ypos * SOURCE_SIZE); clutter_actor_set_clip (actor, 0, 0, DIVISION_WIDTH, DIVISION_HEIGHT); actor = clutter_texture_new_from_actor (actor); clutter_actor_set_position (actor, SOURCE_SIZE, ypos * SOURCE_SIZE); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); ypos++; /* Source clipped to everything but top left division using a path */ actor = create_source (); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); clutter_actor_set_position (actor, 0, ypos * SOURCE_SIZE); g_signal_connect (actor, "paint", G_CALLBACK (pre_paint_clip_cb), NULL); g_signal_connect_after (actor, "paint", G_CALLBACK (post_paint_clip_cb), NULL); actor = clutter_texture_new_from_actor (actor); clutter_actor_set_position (actor, SOURCE_SIZE, ypos * SOURCE_SIZE); clutter_container_add (CLUTTER_CONTAINER (state.stage), actor, NULL); ypos++; /* We force continuous redrawing of the stage, since we need to skip * the first few frames, and we wont be doing anything else that * will trigger redrawing. */ idle_source = g_idle_add (queue_redraw, state.stage); paint_handler = g_signal_connect_after (state.stage, "paint", G_CALLBACK (on_paint), &state); clutter_actor_show_all (state.stage); clutter_main (); g_signal_handler_disconnect (state.stage, paint_handler); g_source_remove (idle_source); /* Remove all of the actors from the stage */ clutter_container_foreach (CLUTTER_CONTAINER (state.stage), (ClutterCallback) clutter_actor_destroy, NULL); if (g_test_verbose ()) g_print ("OK\n"); }