/**
* pkg_graph_set_renderer:
* @graph: A #PkgGraph.
*
* Sets the #PkgRenderer for the graph.
*
* Returns: None.
* Side effects: None.
*/
void
pkg_graph_set_renderer (PkgGraph *graph,
PkgRenderer *renderer)
{
PkgGraphPrivate *priv;
g_return_if_fail(PKG_IS_GRAPH(graph));
g_return_if_fail(PKG_IS_RENDERER(renderer));
priv = graph->priv;
if (priv->renderer) {
clutter_container_remove_actor(CLUTTER_CONTAINER(graph),
CLUTTER_ACTOR(priv->renderer));
g_object_remove_weak_pointer(G_OBJECT(priv->renderer),
(gpointer *)&priv->renderer);
}
priv->renderer = CLUTTER_ACTOR(renderer);
g_object_add_weak_pointer(G_OBJECT(renderer),
(gpointer *)&priv->renderer);
clutter_container_add_actor(CLUTTER_CONTAINER(graph),
CLUTTER_ACTOR(renderer));
pkg_graph_place_child(graph, CLUTTER_ACTOR(renderer));
}
static void
transition_completed_cb (OptTransition *trans,
gpointer data)
{
OptShow *show = (OptShow *)data;
OptSlide *from;
OptShowPrivate *priv;
ClutterActor *stage;
priv = show->priv;
from = opt_transition_get_from (trans);
stage = clutter_stage_get_default();
/* Remove as to free up resources. */
clutter_actor_hide_all (CLUTTER_ACTOR(from));
clutter_container_remove_actor (CLUTTER_CONTAINER(stage),
CLUTTER_ACTOR(from));
/* Reset any tranforms to be safe */
clutter_actor_set_rotation (CLUTTER_ACTOR(from), CLUTTER_X_AXIS, 0, 0, 0, 0);
clutter_actor_set_rotation (CLUTTER_ACTOR(from), CLUTTER_Y_AXIS, 0, 0, 0, 0);
clutter_actor_set_rotation (CLUTTER_ACTOR(from), CLUTTER_Z_AXIS, 0, 0, 0, 0);
/* If needed, update the position */
if (priv->position_label_visible)
opt_show_update_position_label (show);
/* Disconnect the handler */
g_signal_handler_disconnect (trans, priv->trans_signal_id);
priv->trans_signal_id = 0;
}
static void
stop_fullscreen (RBVisualizerPage *page)
{
if (page->fullscreen != NULL) {
ClutterActor *stage;
rb_debug ("stopping fullscreen display");
g_object_ref (page->texture);
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (page->fullscreen_embed));
rb_visualizer_fullscreen_stop (stage);
clutter_container_remove_actor (CLUTTER_CONTAINER (stage), page->texture);
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (page->embed));
clutter_container_add (CLUTTER_CONTAINER (stage), page->texture, NULL);
g_object_unref (page->texture);
gtk_widget_destroy (GTK_WIDGET (page->fullscreen));
page->fullscreen = NULL;
page->fullscreen_embed = NULL;
}
set_action_state (page, FALSE);
}
/**
* mex_menu_clear_all:
* @menu: A #MexMenu
*
* Removes all items from the menu.
*/
void
mex_menu_clear_all (MexMenu *menu)
{
gboolean direction;
GList *l, *children;
MexMenuPrivate *priv;
g_return_if_fail (MEX_IS_MENU (menu));
priv = menu->priv;
if (priv->depth == 0)
return;
children = clutter_container_get_children (CLUTTER_CONTAINER (menu));
direction = (priv->depth >= 0);
for (l = g_list_find (children, clutter_actor_get_parent (priv->layout)); l;
l = direction ? l->next : l->prev)
{
ClutterActor *child = l->data;
clutter_container_remove_actor (CLUTTER_CONTAINER (menu), child);
if (--priv->depth == 0)
break;
}
g_list_free (children);
priv->layout = mex_menu_create_layout (menu, FALSE);
g_object_notify (G_OBJECT (menu), "depth");
}
static void
draw_shadow (BixiMarker *marker,
gint radius)
{
BixiMarkerPrivate *priv = marker->priv;
ClutterActor *shadow = NULL;
cairo_t *cr;
shadow = clutter_cairo_texture_new (radius * 2, radius * 2);
cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (shadow));
draw_box (cr, radius);
cairo_set_source_rgba (cr, 0, 0, 0, 0.25);
cairo_fill (cr);
cairo_destroy (cr);
clutter_actor_set_position (shadow, 3, 3);
clutter_container_add_actor (CLUTTER_CONTAINER (marker), shadow);
if (priv->shadow != NULL)
{
clutter_container_remove_actor (CLUTTER_CONTAINER (marker),
priv->shadow);
g_object_unref (priv->shadow);
}
priv->shadow = g_object_ref (shadow);
}
static void
draw_background (BixiMarker *marker,
gint radius)
{
BixiMarkerPrivate *priv = marker->priv;
ClutterActor *bg = NULL;
ClutterColor color;
ClutterColor darker_color;
gboolean highlighted = FALSE;
guint line_width = 1;
cairo_t *cr;
bg = clutter_cairo_texture_new (radius * 2, radius * 2);
cr = clutter_cairo_texture_create (CLUTTER_CAIRO_TEXTURE (bg));
color = *champlain_marker_get_color (CHAMPLAIN_MARKER (marker));
if (priv->value == 0)
color.alpha = 128;
g_object_get (marker, "highlighted", &highlighted, NULL);
if (highlighted)
{
#if CHAMPLAIN_CHECK_VERSION(0, 4, 1)
color = *champlain_marker_get_highlight_color ();
#else
line_width *= 3;
#endif
}
clutter_color_darken (&color, &darker_color);
draw_box (cr, radius);
cairo_set_source_rgba (cr,
color.red / 255.0,
color.green / 255.0,
color.blue / 255.0,
color.alpha / 255.0);
cairo_fill_preserve (cr);
cairo_set_line_width (cr, line_width);
cairo_set_source_rgba (cr,
darker_color.red / 255.0,
darker_color.green / 255.0,
darker_color.blue / 255.0,
darker_color.alpha / 255.0);
cairo_stroke (cr);
cairo_destroy (cr);
clutter_container_add_actor (CLUTTER_CONTAINER (marker), bg);
if (priv->background != NULL)
{
clutter_container_remove_actor (CLUTTER_CONTAINER (marker),
priv->background);
g_object_unref (priv->background);
}
priv->background = g_object_ref (bg);
}
static void
mex_search_proxy_remove_cb (MexProxy *proxy,
MexContent *content,
ClutterActor *label,
ClutterContainer *layout)
{
clutter_container_remove_actor (layout, label);
}
/**
* champlain_layer_remove_marker:
* @layer: a #ChamplainLayer
* @marker: a #ChamplainBaseMarker
*
* Removes the marker from the layer.
*
* Since: 0.4
*/
void
champlain_layer_remove_marker (ChamplainLayer *layer,
ChamplainBaseMarker *marker)
{
g_return_if_fail (CHAMPLAIN_IS_LAYER (layer));
g_return_if_fail (CHAMPLAIN_IS_BASE_MARKER (marker));
clutter_container_remove_actor (CLUTTER_CONTAINER (layer), CLUTTER_ACTOR (marker));
}
static void
gnibbles_worm_remove_actor (GnibblesWorm *worm)
{
ClutterActor *actor = gnibbles_worm_get_tail_actor (worm);
board->walls[worm->xtail][worm->ytail] = EMPTYCHAR;
clutter_actor_hide (actor);
worm->list = g_list_delete_link (worm->list, g_list_last (worm->list));
clutter_container_remove_actor (CLUTTER_CONTAINER (worm->actors), actor);
}
bool App::clearLast()
{
// XXX if you edit this, also edit clearAll
if (samplers_.size() == 0)
return false;
Sampler *sampler = samplers_[samplers_.size() - 1].get();
clutter_container_remove_actor(CLUTTER_CONTAINER(stage_), sampler->getGenerator()->getRoot());
samplers_.erase(samplers_.end() - 1);
return true;
}
static void
_container_iface_remove (ClutterContainer *container,
ClutterActor *actor)
{
ClutterActor *stage;
stage = mpl_panel_clutter_get_stage (MPL_PANEL_CLUTTER (container));
g_return_if_fail (stage);
clutter_container_remove_actor (CLUTTER_CONTAINER (stage), actor);
}
void
champlain_viewport_set_child (ChamplainViewport *viewport, ClutterActor *child)
{
ChamplainViewportPrivate *priv = viewport->priv;
if (priv->child)
clutter_container_remove_actor (CLUTTER_CONTAINER (priv->content_group), priv->child);
priv->child = child;
clutter_container_add_actor (CLUTTER_CONTAINER (priv->content_group), child);
}
void App::clearAll()
{
// XXX if you edit this, also edit clearLast
std::vector<std::tr1::shared_ptr<Sampler> >::iterator iter;
for (iter = samplers_.begin(); iter < samplers_.end(); ++iter)
{
Sampler *sampler = (*iter).get();
// deletes the ClutterActors
clutter_container_remove_actor(CLUTTER_CONTAINER(stage_), sampler->getGenerator()->getRoot());
}
samplers_.clear();
}
static VALUE
rbclt_container_remove (int argc, VALUE *argv, VALUE self)
{
ClutterContainer *container = CLUTTER_CONTAINER (RVAL2GOBJ (self));
int i;
for (i = 0; i < argc; i++)
{
gpointer actor = RVAL2GOBJ (argv[i]);
if (!CLUTTER_IS_ACTOR (actor))
rb_raise (rb_eArgError, "Actor required");
clutter_container_remove_actor (container, CLUTTER_ACTOR (actor));
}
return self;
}
/**
* clutter_group_remove_all:
* @group: A #ClutterGroup
*
* Removes all children actors from the #ClutterGroup.
*/
void
clutter_group_remove_all (ClutterGroup *group)
{
GList *children;
g_return_if_fail (CLUTTER_IS_GROUP (group));
children = group->priv->children;
while (children)
{
ClutterActor *child = children->data;
children = children->next;
clutter_container_remove_actor (CLUTTER_CONTAINER (group), child);
}
}
void
glide_theme_preview_actor_set_selected (GlideThemePreviewActor *preview,
gboolean selected)
{
preview->priv->selected = selected;
g_object_notify (G_OBJECT (preview), "selected");
if (selected)
{
clutter_container_add_actor (CLUTTER_CONTAINER (preview), preview->priv->border);
clutter_actor_show (preview->priv->border);
}
else
{
clutter_container_remove_actor (CLUTTER_CONTAINER (preview), preview->priv->border);
}
}
/**
* clutter_container_remove_valist:
* @container: a #ClutterContainer
* @first_actor: the first #ClutterActor to add
* @var_args: list of actors to remove, followed by %NULL
*
* Alternative va_list version of clutter_container_remove().
*
* Since: 0.4
*/
void
clutter_container_remove_valist (ClutterContainer *container,
ClutterActor *first_actor,
va_list var_args)
{
ClutterActor *actor;
g_return_if_fail (CLUTTER_IS_CONTAINER (container));
g_return_if_fail (CLUTTER_IS_ACTOR (first_actor));
actor = first_actor;
while (actor)
{
clutter_container_remove_actor (container, actor);
actor = va_arg (var_args, ClutterActor*);
}
}
static gboolean
glide_undo_delete_actor_redo_callback (GlideUndoManager *undo_manager,
GlideUndoInfo *info)
{
GlideUndoDeleteActorData *data =
(GlideUndoDeleteActorData *)info->user_data;
GlideStageManager *manager;
manager = glide_actor_get_stage_manager (GLIDE_ACTOR (data->actor));
if (glide_stage_manager_get_selection (manager) == (GlideActor *)data->actor)
glide_stage_manager_set_selection (manager, NULL);
clutter_container_remove_actor (CLUTTER_CONTAINER (data->parent),
data->actor);
return TRUE;
}
/**
* champlain_group_remove_all:
* @group: A #ChamplainGroup
*
* Removes all children actors from the #ChamplainGroup.
*/
void
champlain_group_remove_all (ChamplainGroup *group)
{
GList *children;
g_return_if_fail (CHAMPLAIN_IS_GROUP (group));
children = group->priv->children;
while (children)
{
ClutterActor *child = children->data;
children = children->next;
clutter_container_remove_actor (CLUTTER_CONTAINER (group), child);
}
group->priv->children_end = NULL;
}
static void
start_fullscreen (RBVisualizerPage *page)
{
if (page->fullscreen == NULL) {
ClutterActor *stage;
GtkWindow *main_window;
RBShell *shell;
int x, y;
rb_debug ("starting fullscreen display");
g_object_get (page, "shell", &shell, NULL);
g_object_get (shell, "window", &main_window, NULL);
page->fullscreen = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (page->fullscreen), TRUE);
/* move the texture from the page embed to the new fullscreen embed */
g_object_ref (page->texture);
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (page->embed));
clutter_container_remove_actor (CLUTTER_CONTAINER (stage), page->texture);
page->fullscreen_embed = create_embed (page);
stage = gtk_clutter_embed_get_stage (GTK_CLUTTER_EMBED (page->fullscreen_embed));
clutter_container_add (CLUTTER_CONTAINER (stage), page->texture, NULL);
g_object_unref (page->texture);
gtk_container_add (GTK_CONTAINER (page->fullscreen), page->fullscreen_embed);
gtk_widget_show_all (GTK_WIDGET (page->fullscreen));
gtk_window_get_position (main_window, &x, &y);
gtk_window_move (GTK_WINDOW (page->fullscreen), x, y);
gtk_window_fullscreen (GTK_WINDOW (page->fullscreen));
gtk_window_set_transient_for (GTK_WINDOW (page->fullscreen), main_window);
g_object_unref (main_window);
rb_visualizer_fullscreen_add_widgets (page->fullscreen, stage, shell);
g_object_unref (shell);
}
set_action_state (page, TRUE);
}
static gboolean idleDestroy(gpointer data)
{
GRefPtr<ClutterActor> actor = adoptGRef(CLUTTER_ACTOR(data));
ClutterActor* parent = clutter_actor_get_parent(actor.get());
// We should remove child actors manually because the container of Clutter
// seems to have a bug to remove its child actors when it is removed.
if (GRAPHICS_LAYER_IS_ACTOR(GRAPHICS_LAYER_ACTOR(actor.get())))
graphicsLayerActorRemoveAll(GRAPHICS_LAYER_ACTOR(actor.get()));
if (parent)
clutter_container_remove_actor(CLUTTER_CONTAINER(parent), actor.get());
// FIXME: we should assert that the actor's ref count is 1 here, but some
// of them are getting here with 2!
// ASSERT((G_OBJECT(actor.get()))->ref_count == 1);
return FALSE;
}
void
mpd_storage_device_tile_show_message_full (MpdStorageDeviceTile *self,
char const *message,
bool replace_buttons,
unsigned int timeout_s,
GSourceFunc function,
void *data)
{
MpdStorageDeviceTilePrivate *priv = GET_PRIVATE (self);
g_return_if_fail (MPD_IS_STORAGE_DEVICE_TILE (self));
if (priv->message == NULL)
{
ClutterText *text;
priv->message = mx_label_new_with_text (message);
mx_stylable_set_style_class (MX_STYLABLE (priv->message), "message");
text = (ClutterText *) mx_label_get_clutter_text (MX_LABEL (priv->message));
clutter_text_set_line_wrap (text, true);
clutter_text_set_line_wrap_mode (text, PANGO_WRAP_WORD);
clutter_text_set_single_line_mode (text, false);
clutter_text_set_ellipsize (text, PANGO_ELLIPSIZE_NONE);
mx_box_layout_add_actor_with_properties (MX_BOX_LAYOUT (self), priv->message,
2,
"x-align", MX_ALIGN_MIDDLE,
NULL);
}
if (replace_buttons)
{
mx_widget_set_disabled (MX_WIDGET (priv->open), true);
mx_widget_set_disabled (MX_WIDGET (priv->eject), true);
clutter_container_remove_actor (CLUTTER_CONTAINER (self), priv->import);
}
mx_label_set_text (MX_LABEL (priv->message), message);
if (timeout_s)
{
g_timeout_add_seconds (timeout_s, function, data);
}
}
/**
* mex_menu_push:
* @menu: A #MexMenu
*
* Increments the current depth of the menu. If the current depth is %0,
* or positive, this will add a new menu level. If the depth is negative,
* this will remove a menu level.
*
* Returns: The new menu depth
*/
gint
mex_menu_push (MexMenu *menu)
{
MexMenuPrivate *priv;
g_return_val_if_fail (MEX_IS_MENU (menu), 0);
priv = menu->priv;
if (priv->depth < 0)
{
GList *l;
GList *children =
clutter_container_get_children (CLUTTER_CONTAINER (menu));
l = g_list_find (children, clutter_actor_get_parent (priv->layout));
priv->layout = l->next->data;
priv->action_layout = g_object_get_data (G_OBJECT (priv->layout),
"action-layout");
clutter_container_remove_actor (CLUTTER_CONTAINER (menu),
CLUTTER_ACTOR (l->data));
g_list_free (children);
priv->depth ++;
priv->focus_on_add = priv->has_focus;
mex_menu_uncheck_buttons (menu);
}
else
{
priv->depth ++;
priv->layout = mex_menu_create_layout (menu, FALSE);
g_object_set_qdata (G_OBJECT (priv->layout),
mex_menu_depth_quark,
GINT_TO_POINTER (priv->depth));
if (priv->has_focus)
priv->focus_on_add = TRUE;
}
g_object_notify (G_OBJECT (menu), "depth");
return priv->depth;
}
static void
st_widget_dispose (GObject *gobject)
{
StWidget *actor = ST_WIDGET (gobject);
StWidgetPrivate *priv = ST_WIDGET (actor)->priv;
if (priv->theme)
{
g_object_unref (priv->theme);
priv->theme = NULL;
}
if (priv->border_image)
{
clutter_actor_unparent (priv->border_image);
priv->border_image = NULL;
}
if (priv->theme_node)
{
g_object_run_dispose (G_OBJECT (priv->theme_node));
g_object_unref (priv->theme_node);
priv->theme_node = NULL;
}
if (priv->tooltip)
{
ClutterContainer *parent;
ClutterActor *tooltip = CLUTTER_ACTOR (priv->tooltip);
/* this is just a little bit awkward because the tooltip is parented
* on the stage, but we still want to "own" it */
parent = CLUTTER_CONTAINER (clutter_actor_get_parent (tooltip));
if (parent)
clutter_container_remove_actor (parent, tooltip);
priv->tooltip = NULL;
}
G_OBJECT_CLASS (st_widget_parent_class)->dispose (gobject);
}
static void
_account_removed_cb (MailmeTelepathy *provider,
MailmeTelepathyAccount *account,
gpointer user_data)
{
PengeEmailPanePrivate *priv = GET_PRIVATE (user_data);
ClutterActor *widget = g_hash_table_lookup (priv->account_to_widget,
account);
if (widget != NULL)
{
g_signal_handlers_disconnect_by_func (account,
_account_changed_cb,
widget);
g_hash_table_remove (priv->account_to_widget, account);
clutter_container_remove_actor (CLUTTER_CONTAINER (user_data),
widget);
}
}
static void
tidy_scroll_view_dispose (GObject *object)
{
TidyScrollViewPrivate *priv = TIDY_SCROLL_VIEW (object)->priv;
if (priv->child)
clutter_container_remove_actor (CLUTTER_CONTAINER (object), priv->child);
if (priv->vscroll)
{
clutter_actor_unparent (priv->vscroll);
priv->vscroll = NULL;
}
if (priv->hscroll)
{
clutter_actor_unparent (priv->hscroll);
priv->hscroll = NULL;
}
G_OBJECT_CLASS (tidy_scroll_view_parent_class)->dispose (object);
}
static void
penge_count_tile_set_compact (PengeCountTile *self,
gboolean compact)
{
PengeCountTilePrivate *priv = self->priv;
if (priv->compact == compact)
return;
priv->compact = compact;
if (compact)
{
clutter_actor_set_width (CLUTTER_ACTOR (self), -1);
g_object_ref (priv->count_label);
clutter_container_remove_actor (CLUTTER_CONTAINER (priv->table),
priv->count_label);
clutter_actor_unparent (priv->count_label);
clutter_actor_add_child ((self), priv->count_label);
penge_count_tile_update_tooltip (self);
}
else
{
clutter_actor_set_width (CLUTTER_ACTOR (self), 280);
clutter_actor_reparent (priv->count_label, priv->table);
clutter_container_child_set (CLUTTER_CONTAINER (priv->table),
priv->count_label,
"column", 0,
"row", 0,
"row-span", 2,
"x-expand", FALSE,
NULL);
clutter_actor_add_child ((self), priv->table);
mx_widget_set_tooltip_text (MX_WIDGET (self), NULL);
}
}
static void
_monitor_mount_changed_cb (GVolumeMonitor *monitor,
GMount *mount,
MpdDevicesTile *self)
{
MpdDevicesTilePrivate *priv = GET_PRIVATE (self);
MpdStorageDeviceTile *tile;
tile = g_hash_table_lookup (priv->tiles, mount);
if (tile)
{
if (!_mount_is_wanted_device (mount))
{
g_hash_table_remove (priv->tiles, mount);
clutter_container_remove_actor (CLUTTER_CONTAINER (priv->vbox),
CLUTTER_ACTOR (tile));
}
} else {
if (_mount_is_wanted_device (mount)) {
add_tile_from_mount (self, mount);
}
}
}
// Each GraphicsLayer has the corresponding layer in the platform port.
// So whenever the list of child layer changes, the list of GraphicsLayerActor should be updated accordingly.
void GraphicsLayerClutter::updateSublayerList()
{
GraphicsLayerActorList newSublayers;
const Vector<GraphicsLayer*>& childLayers = children();
if (childLayers.size() > 0) {
size_t numChildren = childLayers.size();
for (size_t i = 0; i < numChildren; ++i) {
GraphicsLayerClutter* curChild = static_cast<GraphicsLayerClutter*>(childLayers[i]);
GraphicsLayerActor* childLayer = curChild->layerForSuperlayer();
g_assert(GRAPHICS_LAYER_IS_ACTOR(childLayer));
newSublayers.append(childLayer);
}
for (size_t i = 0; i < newSublayers.size(); i++) {
ClutterActor* layerActor = CLUTTER_ACTOR(newSublayers[i].get());
ClutterActor* parentActor = clutter_actor_get_parent(layerActor);
if (parentActor)
clutter_container_remove_actor(CLUTTER_CONTAINER(parentActor), layerActor);
}
}
graphicsLayerActorSetSublayers(m_layer.get(), newSublayers);
}
/**
* pkg_graph_set_scale:
* @graph: A #PkgGraph.
*
* Sets the #PkgScale for the graph.
*
* Returns: None.
* Side effects: None.
*/
void
pkg_graph_set_scale (PkgGraph *graph,
PkgScale *scale)
{
PkgGraphPrivate *priv;
g_return_if_fail(PKG_IS_GRAPH(graph));
g_return_if_fail(PKG_IS_SCALE(scale));
priv = graph->priv;
if (priv->scale) {
clutter_container_remove_actor(CLUTTER_CONTAINER(graph), priv->scale);
g_object_remove_weak_pointer(G_OBJECT(priv->scale),
(gpointer *)&priv->scale);
}
priv->scale = CLUTTER_ACTOR(scale);
g_object_add_weak_pointer(G_OBJECT(scale), (gpointer *)&priv->scale);
clutter_container_add_actor(CLUTTER_CONTAINER(graph),
CLUTTER_ACTOR(scale));
pkg_graph_place_child(graph, CLUTTER_ACTOR(scale));
}
