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 void dawati_bt_request_set_request_type (DawatiBtRequest *request, DawatiBtRequestType type) { DawatiBtRequestPrivate *priv = GET_PRIVATE (request); priv->request = type; switch (type) { case DAWATI_BT_REQUEST_TYPE_AUTH: clutter_actor_hide (priv->request_entry); clutter_actor_show (priv->request_always_btn); break; case DAWATI_BT_REQUEST_TYPE_PIN: case DAWATI_BT_REQUEST_TYPE_PASSKEY: clutter_actor_show (priv->request_entry); clutter_actor_hide (priv->request_always_btn); break; case DAWATI_BT_REQUEST_TYPE_CONFIRM: clutter_actor_hide (priv->request_entry); clutter_actor_hide (priv->request_always_btn); break; default: ; } dawati_bt_request_update_strings (request); }
/* Object initialization * Create private structure and set up default values */ static void xfdashboard_text_box_init(XfdashboardTextBox *self) { XfdashboardTextBoxPrivate *priv; priv=self->priv=XFDASHBOARD_TEXT_BOX_GET_PRIVATE(self); /* This actor is react on events */ clutter_actor_set_reactive(CLUTTER_ACTOR(self), TRUE); /* Set up default values */ priv->padding=0.0f; priv->spacing=0.0f; priv->isEditable=FALSE; priv->primaryIconName=NULL; priv->secondaryIconName=NULL; priv->textFont=NULL; priv->textColor=NULL; priv->selectionTextColor=NULL; priv->selectionBackgroundColor=NULL; priv->hintTextFont=NULL; priv->hintTextColor=NULL; priv->showPrimaryIcon=FALSE; priv->showSecondaryIcon=FALSE; priv->selectionColorSet=FALSE; priv->hintTextSet=FALSE; /* Create actors */ g_signal_connect(self, "key-press-event", G_CALLBACK(_xfdashboard_text_box_on_key_press_event), NULL); g_signal_connect(self, "key-release-event", G_CALLBACK(_xfdashboard_text_box_on_key_release_event), NULL); priv->actorPrimaryIcon=xfdashboard_button_new(); xfdashboard_stylable_add_class(XFDASHBOARD_STYLABLE(priv->actorPrimaryIcon), "primary-icon"); clutter_actor_set_reactive(priv->actorPrimaryIcon, TRUE); clutter_actor_hide(priv->actorPrimaryIcon); clutter_actor_add_child(CLUTTER_ACTOR(self), priv->actorPrimaryIcon); g_signal_connect_swapped(priv->actorPrimaryIcon, "clicked", G_CALLBACK(_xfdashboard_text_box_on_primary_icon_clicked), self); priv->actorSecondaryIcon=xfdashboard_button_new(); xfdashboard_stylable_add_class(XFDASHBOARD_STYLABLE(priv->actorSecondaryIcon), "secondary-icon"); clutter_actor_set_reactive(priv->actorSecondaryIcon, TRUE); clutter_actor_hide(priv->actorSecondaryIcon); clutter_actor_add_child(CLUTTER_ACTOR(self), priv->actorSecondaryIcon); g_signal_connect_swapped(priv->actorSecondaryIcon, "clicked", G_CALLBACK(_xfdashboard_text_box_on_secondary_icon_clicked), self); priv->actorTextBox=clutter_text_new(); clutter_actor_add_child(CLUTTER_ACTOR(self), priv->actorTextBox); clutter_actor_set_reactive(priv->actorTextBox, TRUE); clutter_text_set_selectable(CLUTTER_TEXT(priv->actorTextBox), FALSE); clutter_text_set_editable(CLUTTER_TEXT(priv->actorTextBox), FALSE); clutter_text_set_single_line_mode(CLUTTER_TEXT(priv->actorTextBox), TRUE); g_signal_connect_swapped(priv->actorTextBox, "text-changed", G_CALLBACK(_xfdashboard_text_box_on_text_changed), self); priv->actorHintLabel=clutter_text_new(); clutter_actor_add_child(CLUTTER_ACTOR(self), priv->actorHintLabel); clutter_actor_set_reactive(priv->actorHintLabel, FALSE); clutter_text_set_selectable(CLUTTER_TEXT(priv->actorHintLabel), FALSE); clutter_text_set_editable(CLUTTER_TEXT(priv->actorHintLabel), FALSE); clutter_text_set_single_line_mode(CLUTTER_TEXT(priv->actorHintLabel), TRUE); clutter_actor_hide(priv->actorHintLabel); }
static gboolean start_search (MnpWorldClock *area) { MnpWorldClockPrivate *priv = GET_PRIVATE (area); priv->completion_timeout = 0; if (!priv->completion_inited) { priv->completion_inited = TRUE; construct_completion (area); } priv->search_text = mx_entry_get_text (priv->search_location); if (!priv->search_text || (strlen(priv->search_text) < 3)) clutter_actor_hide(priv->completion); if (priv->search_text && (strlen(priv->search_text) > 2)) g_signal_emit_by_name (priv->zones_model, "filter-changed"); if (priv->search_text && (strlen(priv->search_text) > 2) && (clutter_model_get_n_rows(priv->zones_model) > 0)) { clutter_actor_show(priv->completion); clutter_actor_raise_top (priv->completion); } else { clutter_actor_hide(priv->completion); } return FALSE; }
static void mex_media_controls_show_description (MexMediaControls *self, gboolean show) { MexMediaControlsPrivate *priv = self->priv; MxLabel *label; ClutterActor *play_pause_button, *stop_button, *placeholder, *add_to_queue_button; const gchar *text; label = (MxLabel*) clutter_script_get_object (priv->script, "progress-label"); play_pause_button = (ClutterActor*) clutter_script_get_object (priv->script, "play-pause-button"); stop_button = (ClutterActor*) clutter_script_get_object (priv->script, "stop-button"); add_to_queue_button = (ClutterActor*) clutter_script_get_object (priv->script, "add-to-queue-button"); /* the placeholder actor will accept focus so that the title and description * become visible as the user navigates up and down */ placeholder = (ClutterActor*) clutter_script_get_object (priv->script, "placeholder"); if (show) { clutter_actor_hide (priv->slider); clutter_actor_hide (play_pause_button); clutter_actor_hide (stop_button); clutter_actor_hide (add_to_queue_button); clutter_actor_show (placeholder); if (priv->content) text = mex_content_get_metadata (priv->content, MEX_CONTENT_METADATA_SYNOPSIS); else text = NULL; mx_label_set_text (label, (text) ? text : ""); } else { mx_label_set_text (label, ""); clutter_actor_show (priv->slider); clutter_actor_show (play_pause_button); clutter_actor_show (stop_button); clutter_actor_show (add_to_queue_button); clutter_actor_hide (placeholder); } priv->show_description = show; }
static void prepare_workspace_content(MosesOverview *self, MetaWorkspace *ws) { MosesOverviewPrivate* priv = self->priv; GList* l = meta_workspace_list_windows(ws); if (!priv->clones) { priv->clones = g_ptr_array_new(); } while (l) { MetaWindow* win = l->data; MetaWindowActor* win_actor = META_WINDOW_ACTOR(meta_window_get_compositor_private(win)); if (meta_window_get_window_type(win) == META_WINDOW_DESKTOP) { g_debug("%s: got desktop actor", __func__); priv->background_actor = clutter_clone_new(CLUTTER_ACTOR(win_actor)); } else if (meta_window_get_window_type(win) == META_WINDOW_NORMAL && !meta_window_is_hidden(win)) { ClutterActor* clone = clutter_clone_new(CLUTTER_ACTOR(win_actor)); clutter_actor_set_reactive(clone, TRUE); float x = 0.0, y = 0.0; clutter_actor_get_position(CLUTTER_ACTOR(win_actor), &x, &y); clutter_actor_set_position(clone, x, y); clutter_actor_hide(CLUTTER_ACTOR(win_actor)); g_ptr_array_add(priv->clones, clone); clutter_actor_add_child(CLUTTER_ACTOR(self), clone); g_object_connect(clone, "signal::transitions-completed", G_CALLBACK(on_effect_complete), self, "signal::button-press-event", on_thumb_button_press, self, "signal::enter-event", on_thumb_enter, self, "signal::leave-event", on_thumb_leave, self, NULL); } l = l->next; } ClutterColor clr = CLUTTER_COLOR_INIT(0xff, 0xff, 0xff, 0xff); clutter_actor_set_background_color(CLUTTER_ACTOR(self), &clr); if (priv->background_actor) { #if 0 ClutterEffect* blur = moses_blur_effect_new(); clutter_actor_add_effect_with_name(priv->background_actor, "blur", blur); clutter_actor_insert_child_below(CLUTTER_ACTOR(self), priv->background_actor, NULL); clutter_actor_hide(clutter_clone_get_source(CLUTTER_CLONE(priv->background_actor))); clutter_actor_set_reactive(priv->background_actor, TRUE); #endif } g_object_connect(priv->background_actor ? priv->background_actor: CLUTTER_ACTOR(self), "signal::button-press-event", on_bg_button_press, self, NULL); }
static void fadeout_completed_cb (ClutterAnimation *anim, DawatiBtShell *shell) { DawatiBtShellPrivate *priv = GET_PRIVATE (shell); if (!priv->enabled) { clutter_actor_hide (priv->add_button); clutter_actor_hide (priv->send_button); } }
static gboolean event_box_clicked_cb (ClutterActor *box, ClutterEvent *event, MnpWorldClock *world_clock) { MnpWorldClockPrivate *priv = GET_PRIVATE (world_clock); clutter_actor_hide (priv->completion); clutter_actor_hide (box); return TRUE; }
void mex_telepathy_channel_set_tool_mode (MexTelepathyChannel *self, MexToolMode mode, guint duration) { MexTelepathyChannelPrivate *priv = self->priv; gfloat height; gfloat width; gfloat pref_height; gfloat pref_width; /* Get natural width and height to calculate aspect ratio */ clutter_actor_get_preferred_height (priv->full_frame, -1, NULL, &pref_height); clutter_actor_get_preferred_width (priv->full_frame, -1, NULL, &pref_width); if (mode == TOOL_MODE_PIP) { width = priv->scene_width * 0.25; height = width * (pref_height / pref_width); /* Hide the toolbar and preview areas */ clutter_actor_hide (priv->toolbar_area); clutter_actor_hide (priv->preview_area); } else if (mode == TOOL_MODE_FULL) { height = priv->scene_height * 0.90; width = height * (pref_width / pref_height); /* Show the toolbar and preview areas */ clutter_actor_show (priv->toolbar_area); clutter_actor_show (priv->preview_area); } else if (mode == TOOL_MODE_SBS) { width = priv->scene_width * 0.50; height = width * (pref_height / pref_width); /* Show the toolbar and preview areas */ clutter_actor_hide (priv->toolbar_area); clutter_actor_hide (priv->preview_area); } clutter_actor_animate (priv->full_frame, CLUTTER_EASE_IN_CUBIC, duration, "width", width, "height", height, NULL); }
void mex_player_set_idle_mode (MexPlayer *player, gboolean idle) { MexPlayerPrivate *priv = player->priv; if (priv->idle_mode == idle) return; priv->idle_mode = idle; mex_player_set_controls_visible (player, !idle); if (idle) { gchar *tmp; clutter_actor_hide (priv->controls); clutter_actor_hide (priv->info_panel); mx_widget_set_disabled (MX_WIDGET (player), TRUE); clutter_actor_set_reactive (CLUTTER_ACTOR (player), FALSE); if (priv->content) { save_old_content (player); g_object_unref (priv->content); priv->content = NULL; } tmp = g_strconcat ("file://", mex_get_data_dir (), "/common/style/background-loop.mkv", NULL); clutter_media_set_uri (priv->media, tmp); g_free (tmp); clutter_media_set_playing (priv->media, TRUE); /* we're idle so we don't mind the screensaver coming on */ mex_screensaver_uninhibit (priv->screensaver); } else { clutter_actor_show (priv->controls); clutter_actor_show (priv->info_panel); mx_widget_set_disabled (MX_WIDGET (player), FALSE); clutter_actor_set_reactive (CLUTTER_ACTOR (player), TRUE); clutter_media_set_playing (priv->media, FALSE); clutter_media_set_uri (priv->media, NULL); /* we're playing real content so don't allow the screensaver */ mex_screensaver_inhibit (priv->screensaver); } }
static gboolean _close_dialog_cb (gpointer unused, MexInfoBar *self) { MexInfoBarPrivate *priv = self->priv; if (CLUTTER_ACTOR_IS_VISIBLE (priv->power_dialog)) clutter_actor_hide (priv->power_dialog); if (CLUTTER_ACTOR_IS_VISIBLE (priv->settings_dialog)) clutter_actor_hide (priv->settings_dialog); mex_push_focus (MX_FOCUSABLE (self)); return FALSE; }
static gboolean mex_music_player_captured_event (ClutterActor *actor, ClutterEvent *event) { MexMusicPlayerPrivate *priv = MEX_MUSIC_PLAYER (actor)->priv; ClutterKeyEvent *kevent; if (event->type != CLUTTER_KEY_PRESS) return FALSE; kevent = (ClutterKeyEvent *) event; if (MEX_KEY_INFO (kevent->keyval)) { ClutterActor *tracks; tracks = mex_script_get_actor (priv->script, "tracks-scrollview"); if (CLUTTER_ACTOR_IS_VISIBLE (tracks)) clutter_actor_hide (tracks); else clutter_actor_show (tracks); return TRUE; } return FALSE; }
static void on_sliced_image_loaded (GObject *source_object, GAsyncResult *res, gpointer user_data) { GObject *cache = source_object; AsyncImageData *data = (AsyncImageData *)user_data; GTask *task = G_TASK (res); GList *list, *pixbufs; if (g_task_had_error (task)) return; pixbufs = g_task_propagate_pointer (task, NULL); for (list = pixbufs; list; list = list->next) { ClutterActor *actor = load_from_pixbuf (GDK_PIXBUF (list->data)); clutter_actor_hide (actor); clutter_actor_add_child (data->actor, actor); } g_list_free_full (pixbufs, g_object_unref); if (data->load_callback != NULL) data->load_callback (cache, data->load_callback_data); }
/** * champlain_layer_hide: * @layer: a #ChamplainLayer * * Makes the layer and its markers invisible. * * Since: 0.4 */ void champlain_layer_hide (ChamplainLayer *layer) { g_return_if_fail (CHAMPLAIN_IS_LAYER (layer)); clutter_actor_hide (CLUTTER_ACTOR (layer)); }
static void mex_queue_button_init (MexQueueButton *self) { ClutterActor *temp_text; self->priv = QUEUE_BUTTON_PRIVATE (self); self->priv->inner_box = mx_box_layout_new (); self->priv->icon = mx_icon_new (); self->priv->label = mx_label_new_with_text ("Unknown queue state"); self->priv->spinner = mx_spinner_new (); self->priv->queue_model = mex_queue_model_dup_singleton (); g_signal_connect (self->priv->spinner, "looped", (GCallback)_spinner_looped_cb, self); clutter_container_add (CLUTTER_CONTAINER (self->priv->inner_box), self->priv->label, self->priv->icon, self->priv->spinner, NULL); clutter_container_child_set (CLUTTER_CONTAINER (self->priv->inner_box), self->priv->label, "expand", TRUE, "y-align", MX_ALIGN_MIDDLE, "y-fill", FALSE, NULL); clutter_container_child_set (CLUTTER_CONTAINER (self->priv->inner_box), self->priv->icon, "y-align", MX_ALIGN_MIDDLE, "y-fill", FALSE, "x-align", MX_ALIGN_END, NULL); clutter_container_child_set (CLUTTER_CONTAINER (self->priv->inner_box), self->priv->spinner, "y-align", MX_ALIGN_MIDDLE, "y-fill", FALSE, "x-align", MX_ALIGN_END, NULL); clutter_actor_hide (self->priv->spinner); mx_bin_set_child (MX_BIN (self), self->priv->inner_box); mx_bin_set_fill (MX_BIN (self), TRUE, FALSE); temp_text = mx_label_get_clutter_text (MX_LABEL (self->priv->label)); clutter_text_set_ellipsize (CLUTTER_TEXT (temp_text), PANGO_ELLIPSIZE_NONE); g_signal_connect (self, "notify::toggled", (GCallback)_queue_button_notify_toggled_cb, self); mx_button_set_is_toggle (MX_BUTTON (self), TRUE); }
static void ntf_overlay_urgent_tray_hide_cb (ClutterActor *tray, NtfOverlay *self) { NtfOverlayPrivate *priv = self->priv; clutter_actor_hide (priv->lowlight); }
static gboolean validate_stage (gpointer data_) { ValidateData *data = data_; if (data->check_actor) { data->result = clutter_stage_get_actor_at_pos (CLUTTER_STAGE (data->stage), CLUTTER_PICK_ALL, data->point.x, data->point.y); } if (data->check_color) { data->result = clutter_stage_read_pixels (CLUTTER_STAGE (data->stage), data->point.x, data->point.y, 1, 1); } if (!g_test_verbose ()) { clutter_actor_hide (data->stage); data->was_painted = TRUE; } return G_SOURCE_REMOVE; }
static void mpl_panel_clutter_hide (MplPanelClient *self) { MplPanelClutterPrivate *priv = MPL_PANEL_CLUTTER (self)->priv; clutter_actor_hide (priv->stage); }
/* Show all children of this one */ static void _xfdashboard_text_box_show(ClutterActor *inActor) { XfdashboardTextBox *self=XFDASHBOARD_TEXT_BOX(inActor); XfdashboardTextBoxPrivate *priv=self->priv; /* Show icons */ if(priv->showPrimaryIcon!=FALSE) { clutter_actor_show(CLUTTER_ACTOR(priv->actorPrimaryIcon)); } if(priv->showSecondaryIcon!=FALSE) { clutter_actor_show(CLUTTER_ACTOR(priv->actorSecondaryIcon)); } /* Show hint label depending if text box is empty or not */ if(xfdashboard_text_box_is_empty(self) && priv->isEditable) { clutter_actor_show(priv->actorHintLabel); } else { clutter_actor_hide(priv->actorHintLabel); } clutter_actor_show(CLUTTER_ACTOR(self)); }
int main (int argc, char *argv[]) { ClutterActor *stage; ClutterActor *coglbox; clutter_init(&argc, &argv); stage = clutter_stage_get_default (); clutter_actor_set_size (stage, 400, 400); clutter_stage_set_title (CLUTTER_STAGE (stage), "Cogl Test"); coglbox = test_coglbox_new (); clutter_container_add_actor (CLUTTER_CONTAINER (stage), coglbox); clutter_actor_set_rotation (coglbox, CLUTTER_Y_AXIS, -30, 200, 0, 0); clutter_actor_set_position (coglbox, 0, 100); clutter_actor_show_all (stage); while (1) { clutter_actor_hide (coglbox); clutter_actor_show (coglbox); SPIN(); } return 0; }
/* input handler */ void input_cb (ClutterStage *stage, ClutterEvent *event, gpointer data) { if (event->type == CLUTTER_BUTTON_PRESS) { ClutterActor *a; gfloat x, y; clutter_event_get_coords (event, &x, &y); a = clutter_stage_get_actor_at_pos (stage, CLUTTER_PICK_ALL, x, y); if (a && (CLUTTER_IS_TEXTURE (a) || CLUTTER_IS_CLONE (a))) clutter_actor_hide (a); } else if (event->type == CLUTTER_KEY_PRESS) { g_print ("*** key press event (key:%c) ***\n", clutter_event_get_key_symbol (event)); if (clutter_event_get_key_symbol (event) == CLUTTER_q) gtk_main_quit (); } }
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)); }
void test_clone_no_map (TestConformSimpleFixture *fixture, gconstpointer data) { ClutterActor *stage; ClutterActor *group; ClutterActor *actor; ClutterActor *clone; stage = clutter_stage_get_default (); group = clutter_group_new (); actor = clutter_rectangle_new (); clutter_actor_hide (group); clutter_container_add_actor (CLUTTER_CONTAINER (group), actor); clutter_container_add_actor (CLUTTER_CONTAINER (stage), group); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (group))); g_assert (!(CLUTTER_ACTOR_IS_MAPPED (actor))); clone = clutter_clone_new (group); clutter_container_add_actor (CLUTTER_CONTAINER (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)); }
/** * shell_global_create_root_pixmap_actor: * @global: a #ShellGlobal * * Creates an actor showing the root window pixmap. * * Return value: (transfer none): a #ClutterActor with the root window pixmap. * The actor is floating, hence (transfer none). */ ClutterActor * shell_global_create_root_pixmap_actor (ShellGlobal *global) { GdkWindow *window; ClutterActor *stage; ClutterColor stage_color; /* The actor created is actually a ClutterClone of global->root_pixmap. */ if (global->root_pixmap == NULL) { global->root_pixmap = clutter_glx_texture_pixmap_new (); clutter_texture_set_repeat (CLUTTER_TEXTURE (global->root_pixmap), TRUE, TRUE); /* The low and medium quality filters give nearest-neighbor resizing. */ clutter_texture_set_filter_quality (CLUTTER_TEXTURE (global->root_pixmap), CLUTTER_TEXTURE_QUALITY_HIGH); /* Initialize to the stage color, since that's what will be seen * in the main view if there's no actual background window. */ stage = mutter_plugin_get_stage (global->plugin); clutter_stage_get_color (CLUTTER_STAGE (stage), &stage_color); clutter_texture_set_from_rgb_data (CLUTTER_TEXTURE (global->root_pixmap), /* ClutterColor has the same layout * as one pixel of RGB(A) data. */ (const guchar *)&stage_color, FALSE, /* w, h, rowstride, bpp, flags */ 1, 1, 3, 3, 0, NULL); /* We can only clone an actor within a stage, so we hide the source * texture then add it to the stage */ clutter_actor_hide (global->root_pixmap); clutter_container_add_actor (CLUTTER_CONTAINER (stage), global->root_pixmap); /* This really should never happen; but just in case... */ g_signal_connect (global->root_pixmap, "destroy", G_CALLBACK (root_pixmap_destroy), global); /* Metacity handles changes to some root window properties in its global * event filter, though not _XROOTPMAP_ID. For all root window property * changes, the global filter returns GDK_FILTER_CONTINUE, so our * window specific filter will be called after the global one. * * Because Metacity is already handling root window property updates, * we don't have to worry about adding the PropertyChange mask to the * root window to get PropertyNotify events. */ window = gdk_get_default_root_window (); gdk_window_add_filter (window, root_window_filter, global); update_root_window_pixmap (global); } return clutter_clone_new (global->root_pixmap); }
/* * Minimize effect completion callback; this function restores actor state, and * calls the manager callback function. */ static void on_minimize_effect_complete (ClutterTimeline *timeline, EffectCompleteData *data) { /* * Must reverse the effect of the effect; must hide it first to ensure * that the restoration will not be visible. */ MetaPlugin *plugin = data->plugin; ActorPrivate *apriv; MetaWindowActor *window_actor = META_WINDOW_ACTOR (data->actor); apriv = get_actor_private (META_WINDOW_ACTOR (data->actor)); apriv->tml_minimize = NULL; clutter_actor_hide (data->actor); /* FIXME - we shouldn't assume the original scale, it should be saved * at the start of the effect */ clutter_actor_set_scale (data->actor, 1.0, 1.0); clutter_actor_move_anchor_point_from_gravity (data->actor, CLUTTER_GRAVITY_NORTH_WEST); /* Now notify the manager that we are done with this effect */ meta_plugin_minimize_completed (plugin, window_actor); g_free (data); }
static void mex_search_text_changed_cb (MxEntry *entry, GParamSpec *pspec, MexSearchPlugin *self) { MexSearchPluginPrivate *priv = self->priv; if (priv->suggest_timeout) { g_source_remove (priv->suggest_timeout); priv->suggest_timeout = 0; } /* Don't start suggestions unless we have at least 3 characters */ if (g_utf8_strlen (mx_entry_get_text (entry), -1) < 3) { /* ensure the spinner is not visible */ mx_spinner_set_animating (MX_SPINNER (priv->spinner), FALSE); clutter_actor_hide (priv->spinner); return; } /* show spinner */ mx_spinner_set_animating (MX_SPINNER (priv->spinner), TRUE); clutter_actor_show (priv->spinner); priv->suggest_timeout = g_timeout_add_seconds (1, (GSourceFunc)mex_suggest_timeout_cb, self); }
void xfdashboard_text_box_set_text(XfdashboardTextBox *self, const gchar *inMarkupText) { XfdashboardTextBoxPrivate *priv; const gchar *text; g_return_if_fail(XFDASHBOARD_IS_TEXT_BOX(self)); priv=self->priv; /* Set value if changed */ if(g_strcmp0(clutter_text_get_text(CLUTTER_TEXT(priv->actorTextBox)), inMarkupText)!=0) { clutter_text_set_markup(CLUTTER_TEXT(priv->actorTextBox), inMarkupText); text=clutter_text_get_text(CLUTTER_TEXT(priv->actorTextBox)); if((text==NULL || *text==0) && priv->isEditable) { clutter_actor_show(priv->actorHintLabel); } else { clutter_actor_hide(priv->actorHintLabel); } clutter_actor_queue_relayout(CLUTTER_ACTOR(self)); /* Notify about property change */ g_object_notify_by_pspec(G_OBJECT(self), XfdashboardTextBoxProperties[PROP_TEXT]); } }
static void mx_expander_update (MxExpander *expander) { MxExpanderPrivate *priv = expander->priv; if (priv->expanded) { clutter_actor_set_name (priv->arrow, "mx-expander-arrow-open"); mx_stylable_set_style_class (MX_STYLABLE (expander), "open-expander"); } /* closed state is set when animation is finished */ if (!priv->child) return; /* setup and start the expansion animation */ if (!priv->expanded) { clutter_actor_hide (priv->child); clutter_timeline_set_direction (priv->timeline, CLUTTER_TIMELINE_BACKWARD); } else { clutter_timeline_set_direction (priv->timeline, CLUTTER_TIMELINE_FORWARD); } if (!clutter_timeline_is_playing (priv->timeline)) clutter_timeline_rewind (priv->timeline); clutter_timeline_start (priv->timeline); }
void test_realized (TestConformSimpleFixture *fixture, gconstpointer data) { ClutterActor *actor; ClutterActor *stage; stage = clutter_stage_get_default (); actor = clutter_rectangle_new (); g_assert (!(CLUTTER_ACTOR_IS_REALIZED (actor))); clutter_actor_hide (actor); /* don't show, so won't map */ clutter_container_add_actor (CLUTTER_CONTAINER (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))); clutter_actor_destroy (actor); }
static void set_success (CalibArea *area) { ClutterImage *image; GdkPixbuf *icon = area->icon_success; if (icon == NULL) return; image = CLUTTER_IMAGE (clutter_actor_get_content (area->success_image)); clutter_image_set_data (image, gdk_pixbuf_get_pixels (icon), gdk_pixbuf_get_has_alpha (icon) ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, gdk_pixbuf_get_width (icon), gdk_pixbuf_get_height (icon), gdk_pixbuf_get_rowstride (icon), NULL); clutter_actor_set_size (area->success_image, gdk_pixbuf_get_width (icon), gdk_pixbuf_get_height (icon)); clutter_actor_show (area->success_image); clutter_actor_hide (area->action_layer); }