/* Find view by type */
XfdashboardView* xfdashboard_viewpad_find_view_by_type(XfdashboardViewpad *self, GType inType)
{
ClutterActorIter iter;
ClutterActor *child;
XfdashboardView *view;
g_return_val_if_fail(XFDASHBOARD_IS_VIEWPAD(self), NULL);
view=NULL;
/* Iterate through children and create list of views */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(!view && clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a view and of type looking for */
if(XFDASHBOARD_IS_VIEW(child)==TRUE &&
G_OBJECT_TYPE(child)==inType)
{
view=XFDASHBOARD_VIEW(child);
}
}
/* Return view found which may be NULL if no view of requested type was found */
return(view);
}
/* Find live window actor by window */
static ClutterActor* _xfdashboard_live_workspace_find_by_window(XfdashboardLiveWorkspace *self,
XfdashboardWindowTrackerWindow *inWindow)
{
ClutterActor *child;
ClutterActorIter iter;
ClutterContent *content;
XfdashboardWindowTrackerWindow *window;
g_return_val_if_fail(XFDASHBOARD_IS_LIVE_WORKSPACE(self), NULL);
g_return_val_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_WINDOW(inWindow), NULL);
/* Iterate through list of current actors and find the one for requested window */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
content=clutter_actor_get_content(child);
if(!content || !XFDASHBOARD_IS_WINDOW_CONTENT(content)) continue;
window=xfdashboard_window_content_get_window(XFDASHBOARD_WINDOW_CONTENT(content));
if(window==inWindow) return(child);
}
/* If we get here we did not find the window and we return NULL */
return(NULL);
}
/* Dispose this object */
static void _xfdashboard_view_selector_dispose(GObject *inObject)
{
XfdashboardViewSelector *self=XFDASHBOARD_VIEW_SELECTOR(inObject);
XfdashboardViewSelectorPrivate *priv=self->priv;
ClutterActorIter iter;
ClutterActor *child;
gpointer view;
/* Release allocated resources */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a button otherwise continue iterating */
if(!XFDASHBOARD_IS_TOGGLE_BUTTON(child)) continue;
/* If button has reference to a view remove signal handlers it */
view=g_object_get_data(G_OBJECT(child), "view");
if(view) g_signal_handlers_disconnect_by_data(view, child);
}
if(priv->viewpad)
{
g_signal_handlers_disconnect_by_data(priv->viewpad, self);
g_object_unref(priv->viewpad);
priv->viewpad=NULL;
}
/* Call parent's class dispose method */
G_OBJECT_CLASS(xfdashboard_view_selector_parent_class)->dispose(inObject);
}
static void
clutter_bin_layout_get_preferred_height (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_width,
gfloat *min_height_p,
gfloat *nat_height_p)
{
ClutterActor *actor = CLUTTER_ACTOR (container);
ClutterActorIter iter;
ClutterActor *child;
gfloat min_height, nat_height;
min_height = nat_height = 0.0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat minimum, natural;
clutter_actor_get_preferred_height (child, for_width,
&minimum,
&natural);
min_height = MAX (min_height, minimum);
nat_height = MAX (nat_height, natural);
}
if (min_height_p)
*min_height_p = min_height;
if (nat_height_p)
*nat_height_p = nat_height;
}
static void
mx_table_actor_removed (ClutterContainer *container,
ClutterActor *actor)
{
MxTablePrivate *priv = MX_TABLE (container)->priv;
gint rows, cols;
MxTableChild *meta;
ClutterActorIter iter;
ClutterActor *child;
if ((ClutterActor *)priv->last_focus == actor)
priv->last_focus = NULL;
/* update row/column count */
rows = 0;
cols = 0;
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (container));
while (clutter_actor_iter_next (&iter, &child))
{
meta = (MxTableChild *) clutter_container_get_child_meta (container,
child);
rows = MAX (rows, meta->row + meta->row_span);
cols = MAX (cols, meta->col + meta->col_span);
}
priv->n_rows = rows;
priv->n_cols = cols;
clutter_actor_queue_relayout (CLUTTER_ACTOR (container));
}
/* Re-layout and allocate children of container we manage */
static void _xfdashboard_box_layout_allocate(ClutterLayoutManager *inLayoutManager,
ClutterContainer *inContainer,
const ClutterActorBox *inAllocation,
ClutterAllocationFlags inFlags)
{
ClutterTextDirection textDirection;
ClutterActor *child;
ClutterActorIter iter;
ClutterActorBox childBox;
gfloat containerWidth;
g_return_if_fail(XFDASHBOARD_IS_BOX_LAYOUT(inLayoutManager));
g_return_if_fail(CLUTTER_IS_CONTAINER(inContainer));
/* Chain up to calculate and store the allocation of children */
CLUTTER_LAYOUT_MANAGER_CLASS(xfdashboard_box_layout_parent_class)->allocate(inLayoutManager,
inContainer,
inAllocation,
inFlags);
/* Right-to-left text direction only affects horizontal orientation.
* If orientation is not horizontal or text direction is not right-to-left
* then there is nothing to do.
*/
if(clutter_box_layout_get_orientation(CLUTTER_BOX_LAYOUT(inLayoutManager))!=CLUTTER_ORIENTATION_HORIZONTAL)
{
return;
}
textDirection=clutter_actor_get_text_direction(CLUTTER_ACTOR(inContainer));
if(textDirection==CLUTTER_TEXT_DIRECTION_DEFAULT) textDirection=clutter_get_default_text_direction();
if(textDirection!=CLUTTER_TEXT_DIRECTION_RTL)
{
return;
}
/* Iterate through children and recalculate x-coordination of each
* children allocation by "mirroring" x-coordinate.
*/
containerWidth=clutter_actor_box_get_width(inAllocation);
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(inContainer));
while(clutter_actor_iter_next(&iter, &child))
{
gfloat x1, x2;
/* Get position and size of child */
clutter_actor_get_allocation_box(child, &childBox);
/* Set new allocation of child */
x1=containerWidth-childBox.x2;
x2=containerWidth-childBox.x1;
childBox.x1=x1;
childBox.x2=x2;
clutter_actor_allocate(child, &childBox, inFlags);
}
}
/* Dump actors */
static void _xfdashboard_dump_actor_internal(ClutterActor *inActor, gint inLevel)
{
ClutterActorIter iter;
ClutterActor *child;
gint i;
g_return_if_fail(CLUTTER_IS_ACTOR(inActor));
g_return_if_fail(inLevel>=0);
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(inActor));
while(clutter_actor_iter_next(&iter, &child))
{
for(i=0; i<inLevel; i++) g_print(" ");
g_print("+- %s@%p - name: %s - geometry: %.2f,%.2f [%.2fx%.2f], mapped: %s, visible: %s, children: %d\n",
G_OBJECT_TYPE_NAME(child), child,
clutter_actor_get_name(child),
clutter_actor_get_x(child),
clutter_actor_get_y(child),
clutter_actor_get_width(child),
clutter_actor_get_height(child),
clutter_actor_is_mapped(child) ? "yes" : "no",
clutter_actor_is_visible(child) ? "yes" : "no",
clutter_actor_get_n_children(child));
if(clutter_actor_get_n_children(child)>0) _xfdashboard_dump_actor_internal(child, inLevel+1);
}
}
/* Invalidate all stylable children recursively beginning at given actor */
static void _xfdashboard_actor_invalidate_recursive(ClutterActor *inActor)
{
ClutterActor *child;
ClutterActorIter actorIter;
g_return_if_fail(CLUTTER_IS_ACTOR(inActor));
/* If actor is stylable invalidate it to get its style recomputed */
if(XFDASHBOARD_IS_STYLABLE(inActor))
{
xfdashboard_stylable_invalidate(XFDASHBOARD_STYLABLE(inActor));
}
/* Recompute styles for all children recursively */
clutter_actor_iter_init(&actorIter, inActor);
while(clutter_actor_iter_next(&actorIter, &child))
{
/* Call ourselve recursive with child as top-level actor.
* We return immediately if it has no children but invalidate child
* before. If it has children it will first invalidated and will be
* iterated over its children then. In both cases the child will
* be invalidated.
*/
_xfdashboard_actor_invalidate_recursive(child);
}
}
/* Find live workspace actor for native workspace */
static XfdashboardLiveWorkspace* _xfdashboard_workspace_selector_find_actor_for_workspace(XfdashboardWorkspaceSelector *self,
XfdashboardWindowTrackerWorkspace *inWorkspace)
{
ClutterActorIter iter;
ClutterActor *child;
XfdashboardLiveWorkspace *liveWorkspace;
g_return_val_if_fail(XFDASHBOARD_IS_WORKSPACE_SELECTOR(self), NULL);
g_return_val_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_WORKSPACE(inWorkspace), NULL);
/* Iterate through workspace actor and lookup the one handling requesting workspace */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
if(XFDASHBOARD_IS_LIVE_WORKSPACE(child))
{
liveWorkspace=XFDASHBOARD_LIVE_WORKSPACE(child);
if(xfdashboard_live_workspace_get_workspace(liveWorkspace)==inWorkspace)
{
return(liveWorkspace);
}
}
}
return(NULL);
}
/* Called when a view was removed to viewpad */
static void _xfdashboard_view_selector_on_view_removed(XfdashboardViewSelector *self,
XfdashboardView *inView,
gpointer inUserData)
{
ClutterActorIter iter;
ClutterActor *child;
gpointer view;
g_return_if_fail(XFDASHBOARD_IS_VIEW_SELECTOR(self));
/* Iterate through create views and lookup view of given type */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a button otherwise continue iterating */
if(!XFDASHBOARD_IS_TOGGLE_BUTTON(child)) continue;
/* If button has reference to view destroy it */
view=g_object_get_data(G_OBJECT(child), "view");
if(XFDASHBOARD_IS_VIEW(view) && XFDASHBOARD_VIEW(view)==inView)
{
clutter_actor_destroy(child);
}
}
}
/* Find view by internal name */
XfdashboardView* xfdashboard_viewpad_find_view_by_name(XfdashboardViewpad *self, const gchar *inInternalName)
{
ClutterActorIter iter;
ClutterActor *child;
XfdashboardView *view;
g_return_val_if_fail(XFDASHBOARD_IS_VIEWPAD(self), NULL);
view=NULL;
/* Iterate through children and lookup view matching requested name */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(!view && clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a view and its internal name matches requested name */
if(XFDASHBOARD_IS_VIEW(child)==TRUE &&
g_strcmp0(xfdashboard_view_get_internal_name(XFDASHBOARD_VIEW(child)), inInternalName)==0)
{
view=XFDASHBOARD_VIEW(child);
}
}
/* Return view found which may be NULL if no view of requested type was found */
return(view);
}
static void
meta_surface_actor_pick (ClutterActor *actor,
const ClutterColor *color)
{
MetaSurfaceActor *self = META_SURFACE_ACTOR (actor);
MetaSurfaceActorPrivate *priv =
meta_surface_actor_get_instance_private (self);
ClutterActorIter iter;
ClutterActor *child;
if (!clutter_actor_should_pick_paint (actor))
return;
/* If there is no region then use the regular pick */
if (priv->input_region == NULL)
CLUTTER_ACTOR_CLASS (meta_surface_actor_parent_class)->pick (actor, color);
else
{
int n_rects;
float *rectangles;
int i;
CoglPipeline *pipeline;
CoglContext *ctx;
CoglFramebuffer *fb;
CoglColor cogl_color;
n_rects = cairo_region_num_rectangles (priv->input_region);
rectangles = g_alloca (sizeof (float) * 4 * n_rects);
for (i = 0; i < n_rects; i++)
{
cairo_rectangle_int_t rect;
int pos = i * 4;
cairo_region_get_rectangle (priv->input_region, i, &rect);
rectangles[pos + 0] = rect.x;
rectangles[pos + 1] = rect.y;
rectangles[pos + 2] = rect.x + rect.width;
rectangles[pos + 3] = rect.y + rect.height;
}
ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
fb = cogl_get_draw_framebuffer ();
cogl_color_init_from_4ub (&cogl_color, color->red, color->green, color->blue, color->alpha);
pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color (pipeline, &cogl_color);
cogl_framebuffer_draw_rectangles (fb, pipeline, rectangles, n_rects);
cogl_object_unref (pipeline);
}
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
clutter_actor_paint (child);
}
/* Allocate position and size of actor and its children */
static void _xfdashboard_live_workspace_allocate(ClutterActor *self,
const ClutterActorBox *inBox,
ClutterAllocationFlags inFlags)
{
XfdashboardLiveWorkspacePrivate *priv=XFDASHBOARD_LIVE_WORKSPACE(self)->priv;
gfloat availableWidth, availableHeight;
gfloat workspaceWidth, workspaceHeight;
ClutterContent *content;
XfdashboardWindowTrackerWindow *window;
gint x, y, w, h;
ClutterActor *child;
ClutterActorIter iter;
ClutterActorBox childAllocation={ 0, };
/* Chain up to store the allocation of the actor */
CLUTTER_ACTOR_CLASS(xfdashboard_live_workspace_parent_class)->allocate(self, inBox, inFlags);
/* If we handle no workspace to not set allocation of children */
if(!priv->workspace) return;
/* Get size of workspace and this allocation as it is needed
* to calculate translated position and size
*/
clutter_actor_box_get_size(inBox, &availableWidth, &availableHeight);
workspaceWidth=(gfloat)xfdashboard_window_tracker_workspace_get_width(priv->workspace);
workspaceHeight=(gfloat)xfdashboard_window_tracker_workspace_get_height(priv->workspace);
/* Iterate through window actors, calculate translated allocation of
* position and size to available size of this actor
*/
clutter_actor_iter_init(&iter, self);
while(clutter_actor_iter_next(&iter, &child))
{
/* Get window actor */
if(!CLUTTER_IS_ACTOR(child)) continue;
/* Get associated window */
content=clutter_actor_get_content(child);
if(!content || !XFDASHBOARD_IS_WINDOW_CONTENT(content)) continue;
window=xfdashboard_window_content_get_window(XFDASHBOARD_WINDOW_CONTENT(content));
if(!window) continue;
/* Get real size of child */
xfdashboard_window_tracker_window_get_position_size(window, &x, &y, &w, &h);
/* Calculate translated position and size of child */
childAllocation.x1=ceil((x/workspaceWidth)*availableWidth);
childAllocation.y1=ceil((y/workspaceHeight)*availableHeight);
childAllocation.x2=childAllocation.x1+ceil((w/workspaceWidth)*availableWidth);
childAllocation.y2=childAllocation.y1+ceil((h/workspaceHeight)*availableHeight);
/* Set allocation of child */
clutter_actor_allocate(child, &childAllocation, inFlags);
}
}
/* Allocate position and size of actor and its children */
static void _xfdashboard_workspace_selector_allocate(ClutterActor *inActor,
const ClutterActorBox *inBox,
ClutterAllocationFlags inFlags)
{
XfdashboardWorkspaceSelector *self=XFDASHBOARD_WORKSPACE_SELECTOR(inActor);
XfdashboardWorkspaceSelectorPrivate *priv=self->priv;
gfloat availableWidth, availableHeight;
gfloat childWidth, childHeight;
ClutterActor *child;
ClutterActorIter iter;
ClutterActorBox childAllocation={ 0, };
/* Chain up to store the allocation of the actor */
CLUTTER_ACTOR_CLASS(xfdashboard_workspace_selector_parent_class)->allocate(inActor, inBox, inFlags);
/* Get available size */
clutter_actor_box_get_size(inBox, &availableWidth, &availableHeight);
/* Calculate new position and size of visible children */
childAllocation.x1=childAllocation.y1=priv->spacing;
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(inActor));
while(clutter_actor_iter_next(&iter, &child))
{
/* Is child visible? */
if(!CLUTTER_ACTOR_IS_VISIBLE(child)) continue;
/* Calculate new position and size of child */
if(priv->orientation==CLUTTER_ORIENTATION_HORIZONTAL)
{
childHeight=availableHeight-(2*priv->spacing);
clutter_actor_get_preferred_width(child, childHeight, NULL, &childWidth);
childAllocation.y1=ceil(MAX(((availableHeight-childHeight))/2.0f, priv->spacing));
childAllocation.y2=floor(childAllocation.y1+childHeight);
childAllocation.x2=floor(childAllocation.x1+childWidth);
}
else
{
childWidth=availableWidth-(2*priv->spacing);
clutter_actor_get_preferred_height(child, childWidth, NULL, &childHeight);
childAllocation.x1=ceil(MAX(((availableWidth-childWidth))/2.0f, priv->spacing));
childAllocation.x2=floor(childAllocation.x1+childWidth);
childAllocation.y2=floor(childAllocation.y1+childHeight);
}
clutter_actor_allocate(child, &childAllocation, inFlags);
/* Set up for next child */
if(priv->orientation==CLUTTER_ORIENTATION_HORIZONTAL) childAllocation.x1=floor(childAllocation.x1+childWidth+priv->spacing);
else childAllocation.y1=floor(childAllocation.y1+childHeight+priv->spacing);
}
}
static void
mx_table_paint (ClutterActor *self)
{
MxTablePrivate *priv = MX_TABLE (self)->priv;
ClutterActorIter iter;
ClutterActor *child;
/* make sure the background gets painted first */
CLUTTER_ACTOR_CLASS (mx_table_parent_class)->paint (self);
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
{
if (CLUTTER_ACTOR_IS_VISIBLE (child))
clutter_actor_paint (child);
}
if (_mx_debug (MX_DEBUG_LAYOUT))
{
int i;
float width, height;
gfloat pos = 0;
DimensionData *rows, *cols;
rows = &g_array_index (priv->rows, DimensionData, 0);
cols = &g_array_index (priv->columns, DimensionData, 0);
clutter_actor_get_size (self, &width, &height);
cogl_set_source_color4f (0.0, 0.0, 1.0, 0.7);
for (i = 0; i < priv->n_rows; i++)
{
cogl_rectangle (0, pos, 10, pos + rows[i].final_size);
pos += rows[i].final_size + priv->row_spacing;
}
cogl_set_source_color4f (1.0, 0.0, 0.0, 0.7);
pos = 0;
for (i = 0; i < priv->n_rows; i++)
{
cogl_rectangle (pos, 0, pos + cols[i].final_size, 10);
pos += cols[i].final_size + priv->col_spacing;
}
}
}
/* content view */
static void
mex_music_player_set_content (MexContentView *player,
MexContent *content)
{
MexMusicPlayerPrivate *priv = MEX_MUSIC_PLAYER (player)->priv;
gchar *album_artist;
const gchar *uri, *album, *artist, *title;
ClutterActorIter iter;
ClutterActor *child, *container;
if (priv->content)
g_object_unref (priv->content);
priv->content = content;
if (!content)
return;
g_object_ref (content);
/* title */
title = mex_content_get_metadata (content, MEX_CONTENT_METADATA_TITLE);
mx_label_set_text (MX_LABEL (priv->title_label), title);
/* subtitle (album, artist) */
album = mex_content_get_metadata (content, MEX_CONTENT_METADATA_ALBUM);
artist = mex_content_get_metadata (content, MEX_CONTENT_METADATA_ARTIST);
album_artist = g_strconcat (album, ", ", artist , NULL);
mx_label_set_text (MX_LABEL (priv->subtitle_label), album_artist);
g_free (album_artist);
/* uri */
uri = mex_content_get_metadata (content, MEX_CONTENT_METADATA_STREAM);
clutter_media_set_uri (priv->player, uri);
/* find the item in the list */
container = mex_script_get_actor (priv->script, "tracks");
clutter_actor_iter_init (&iter, container);
while (clutter_actor_iter_next (&iter, &child))
{
MexContent *button_content;
button_content = g_object_get_data (G_OBJECT (child), "content");
mx_button_set_toggled (MX_BUTTON (child), (button_content == content));
}
}
static void
ntf_tray_dismiss_all_cb (ClutterActor *button, NtfTray *tray)
{
NtfTrayPrivate *priv = tray->priv;
ClutterActorIter iter;
ClutterActor *child;
clutter_actor_hide (CLUTTER_ACTOR (tray));
clutter_actor_iter_init (&iter, priv->notifiers);
while (clutter_actor_iter_next (&iter, &child))
{
g_signal_emit_by_name (child, "closed", 0);
}
}
static void
_cancel_request_cb (DawatiBtShell *shell)
{
DawatiBtShellPrivate *priv = GET_PRIVATE (shell);
ClutterActorIter iter;
ClutterActor *child;
clutter_actor_iter_init (&iter, priv->request_box);
while (clutter_actor_iter_next (&iter, &child))
clutter_actor_remove_child (priv->request_box, child);
g_hash_table_remove_all (priv->requests);
notify_notification_close (priv->notification, NULL);
}
static void _xfdashboard_dump_actor_internal(ClutterActor *inActor, gint inLevel)
{
ClutterActorIter iter;
ClutterActor *child;
g_return_if_fail(CLUTTER_IS_ACTOR(inActor));
g_return_if_fail(inLevel>0);
/* Dump children */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(inActor));
while(clutter_actor_iter_next(&iter, &child))
{
_xfdashboard_dump_actor_print(child, inLevel);
if(clutter_actor_get_n_children(child)>0) _xfdashboard_dump_actor_internal(child, inLevel+1);
}
}
/**
* meta_cullable_reset_culling_children:
* @cullable: The #MetaCullable
*
* This is a helper method for actors that want to recurse over their
* child actors, and cull them out.
*
* See #MetaCullable and meta_cullable_reset_culling() for more details.
*/
void
meta_cullable_reset_culling_children (MetaCullable *cullable)
{
ClutterActor *actor = CLUTTER_ACTOR (cullable);
ClutterActor *child;
ClutterActorIter iter;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
if (!META_IS_CULLABLE (child))
continue;
meta_cullable_reset_culling (META_CULLABLE (child));
}
}
static void
mx_table_pick (ClutterActor *self,
const ClutterColor *color)
{
ClutterActorIter iter;
ClutterActor *child;
/* Chain up so we get a bounding box painted (if we are reactive) */
CLUTTER_ACTOR_CLASS (mx_table_parent_class)->pick (self, color);
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
{
if (CLUTTER_ACTOR_IS_VISIBLE (child))
clutter_actor_paint (child);
}
}
/* A view was disabled */
static void _xfdashboard_viewpad_on_view_disabled(XfdashboardViewpad *self, XfdashboardView *inView)
{
XfdashboardViewpadPrivate *priv;
ClutterActorIter iter;
ClutterActor *child;
XfdashboardView *firstActivatableView;
g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(self));
g_return_if_fail(XFDASHBOARD_IS_VIEW(inView));
priv=self->priv;
firstActivatableView=NULL;
/* If the currently disabled view is the active one, activate a next available view */
if(inView==priv->activeView)
{
/* Iterate through create views and lookup view of given type */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a view otherwise continue iterating */
if(XFDASHBOARD_IS_VIEW(child)!=TRUE) continue;
/* If child is not the view being disabled check if it could
* become the next activatable view
* the first activatable view after we destroyed all views found.
*/
if(XFDASHBOARD_VIEW(child)!=inView &&
xfdashboard_view_get_enabled(XFDASHBOARD_VIEW(child)))
{
firstActivatableView=XFDASHBOARD_VIEW(child);
}
}
/* Now activate the first activatable view we found during iteration.
* It can also be no view (NULL pointer).
*/
g_debug("Disabled view %s was the active view in %s - will activate %s",
G_OBJECT_TYPE_NAME(inView),
G_OBJECT_TYPE_NAME(self),
firstActivatableView ? G_OBJECT_TYPE_NAME(firstActivatableView) : "no other view");
_xfdashboard_viewpad_activate_view(self, firstActivatableView);
}
}
static void
_devices_changed_cb(BluetoothApplet *applet,
DawatiBtShell *shell)
{
DawatiBtShellPrivate *priv = GET_PRIVATE (shell);
GList *devices;
ClutterActorIter iter;
ClutterActor *child;
devices = bluetooth_applet_get_devices (applet);
g_list_foreach (devices, (GFunc)_handle_device, shell);
g_list_free_full (devices, _bluetooth_simple_device_free);
clutter_actor_iter_init (&iter, priv->device_box);
while (clutter_actor_iter_next (&iter, &child))
_remove_non_connected_device (child, shell);
dawati_bt_shell_update (shell);
}
/* Get list of views */
GList* xfdashboard_viewpad_get_views(XfdashboardViewpad *self)
{
ClutterActorIter iter;
ClutterActor *child;
GList *list;
g_return_val_if_fail(XFDASHBOARD_IS_VIEWPAD(self), NULL);
list=NULL;
/* Iterate through children and create list of views */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a view and add to list */
if(XFDASHBOARD_IS_VIEW(child)==TRUE) list=g_list_prepend(list, child);
}
list=g_list_reverse(list);
return(list);
}
/* Called when a view type was unregistered */
static void _xfdashboard_viewpad_on_view_unregistered(XfdashboardViewpad *self,
GType inViewType,
gpointer inUserData)
{
XfdashboardViewpadPrivate *priv;
ClutterActorIter iter;
ClutterActor *child;
ClutterActor *firstActivatableView;
g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(self));
priv=self->priv;
firstActivatableView=NULL;
/* Iterate through create views and lookup view of given type */
clutter_actor_iter_init(&iter, CLUTTER_ACTOR(self));
while(clutter_actor_iter_next(&iter, &child))
{
/* Check if child is a view otherwise continue iterating */
if(XFDASHBOARD_IS_VIEW(child)!=TRUE) continue;
/* If child is not of type being unregistered it will get
* the first activatable view after we destroyed all views found.
*/
if(G_OBJECT_TYPE(child)!=inViewType)
{
if(xfdashboard_view_get_enabled(XFDASHBOARD_VIEW(child))) firstActivatableView=child;
}
else
{
if(G_OBJECT(child)==G_OBJECT(priv->activeView)) _xfdashboard_viewpad_activate_view(self, NULL);
g_signal_emit(self, XfdashboardViewpadSignals[SIGNAL_VIEW_REMOVED], 0, child);
clutter_actor_destroy(child);
}
}
/* Now activate the first activatable view we found during iteration */
if(firstActivatableView) _xfdashboard_viewpad_activate_view(self, XFDASHBOARD_VIEW(firstActivatableView));
}
/* Internal function to traverse an actor which can be call recursively */
static gboolean _xfdashboard_traverse_actor_internal(ClutterActor *inActor,
XfdashboardCssSelector *inSelector,
XfdashboardTraversalCallback inCallback,
gpointer inUserData)
{
ClutterActorIter iter;
ClutterActor *child;
gint score;
gboolean doContinueTraversal;
g_return_val_if_fail(CLUTTER_IS_ACTOR(inActor), XFDASHBOARD_TRAVERSAL_CONTINUE);
g_return_val_if_fail(XFDASHBOARD_IS_CSS_SELECTOR(inSelector), XFDASHBOARD_TRAVERSAL_CONTINUE);
g_return_val_if_fail(inCallback, XFDASHBOARD_TRAVERSAL_CONTINUE);
/* Check if given actor matches selector if a selector is provided
* otherwise each child will match. Call callback for matching children.
*/
if(XFDASHBOARD_IS_STYLABLE(inActor))
{
score=xfdashboard_css_selector_score_matching_stylable_node(inSelector, XFDASHBOARD_STYLABLE(inActor));
if(score>=0)
{
doContinueTraversal=(inCallback)(inActor, inUserData);
if(!doContinueTraversal) return(doContinueTraversal);
}
}
/* For each child of actor call ourselve recursive */
clutter_actor_iter_init(&iter, inActor);
while(clutter_actor_iter_next(&iter, &child))
{
doContinueTraversal=_xfdashboard_traverse_actor_internal(child, inSelector, inCallback, inUserData);
if(!doContinueTraversal) return(doContinueTraversal);
}
/* If we get here return and continue traversal */
return(XFDASHBOARD_TRAVERSAL_CONTINUE);
}
/**
* xfdashboard_find_actor_by_name:
* @inActor: The root #ClutterActor where to begin searching
* @inName: A string containg the name of the #ClutterActor to lookup
*
* Iterates through all children of @inActor recursively and looks for
* the child having the name as specified at @inName.
*
* Return value: (transfer none): The #ClutterActor matching the name
* to lookup or %NULL if none was found.
*/
ClutterActor* xfdashboard_find_actor_by_name(ClutterActor *inActor, const gchar *inName)
{
ClutterActorIter iter;
ClutterActor *child;
ClutterActor *result;
g_return_val_if_fail(CLUTTER_IS_ACTOR(inActor), NULL);
g_return_val_if_fail(inName && *inName, NULL);
/* Check if given actor is the one we should lookup */
if(g_strcmp0(clutter_actor_get_name(inActor), inName)==0) return(inActor);
/* For each child of actor call ourselve recursive */
clutter_actor_iter_init(&iter, inActor);
while(clutter_actor_iter_next(&iter, &child))
{
result=xfdashboard_find_actor_by_name(child, inName);
if(result) return(result);
}
/* If we get here you could not find actor having this name set */
return(NULL);
}
static ClutterActor*
mx_table_find_actor_at (MxTable *table,
int row,
int column)
{
ClutterActorIter iter;
ClutterActor *actor_child;
clutter_actor_iter_init (&iter, CLUTTER_ACTOR (table));
while (clutter_actor_iter_next (&iter, &actor_child))
{
MxTableChild *child;
child = (MxTableChild *) clutter_container_get_child_meta (CLUTTER_CONTAINER (table),
actor_child);
if ((row >= child->row && row <= child->row + (child->row_span - 1)) &&
(column >= child->col && column <= child->col + (child->col_span - 1)))
return actor_child;
}
return NULL;
}
/* Adapted from clutter_actor_update_default_paint_volume() */
static gboolean
meta_window_group_get_paint_volume (ClutterActor *self,
ClutterPaintVolume *volume)
{
ClutterActorIter iter;
ClutterActor *child;
clutter_actor_iter_init (&iter, self);
while (clutter_actor_iter_next (&iter, &child))
{
const ClutterPaintVolume *child_volume;
if (!CLUTTER_ACTOR_IS_MAPPED (child))
continue;
child_volume = clutter_actor_get_transformed_paint_volume (child, self);
if (child_volume == NULL)
return FALSE;
clutter_paint_volume_union (volume, child_volume);
}
return TRUE;
}
static void
clutter_bin_layout_get_preferred_width (ClutterLayoutManager *manager,
ClutterContainer *container,
gfloat for_height,
gfloat *min_width_p,
gfloat *nat_width_p)
{
ClutterActor *actor = CLUTTER_ACTOR (container);
ClutterActorIter iter;
ClutterActor *child;
gfloat min_width, nat_width;
min_width = nat_width = 0.0;
clutter_actor_iter_init (&iter, actor);
while (clutter_actor_iter_next (&iter, &child))
{
gfloat minimum, natural;
if (!clutter_actor_is_visible (child))
continue;
clutter_actor_get_preferred_width (child, for_height,
&minimum,
&natural);
min_width = MAX (min_width, minimum);
nat_width = MAX (nat_width, natural);
}
if (min_width_p)
*min_width_p = min_width;
if (nat_width_p)
*nat_width_p = nat_width;
}
