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