static void mex_content_box_paint (ClutterActor *actor) { MexContentBoxPrivate *priv = MEX_CONTENT_BOX (actor)->priv; gboolean clipped = FALSE; CLUTTER_ACTOR_CLASS (mex_content_box_parent_class)->paint (actor); if (G_UNLIKELY (priv->clip_to_allocation)) { ClutterActorBox box; clutter_actor_get_allocation_box (actor, &box); cogl_clip_push_rectangle (0, 0, box.x2 - box.x1, box.y2 - box.y1); clipped = TRUE; } clutter_actor_paint (priv->tile); if (G_UNLIKELY (priv->extras_visible)) { ClutterActorBox box; clutter_actor_paint (priv->action_list); clutter_actor_paint (priv->info_panel); /* separator */ cogl_set_source_color4ub (255, 255, 255, 51); clutter_actor_get_allocation_box (priv->info_panel, &box); cogl_path_line (box.x1, box.y1, box.x2, box.y1); cogl_path_stroke (); } if (G_UNLIKELY (clipped)) cogl_clip_pop (); }
static void clutter_clone_apply_transform (ClutterActor *self, CoglMatrix *matrix) { ClutterClonePrivate *priv = CLUTTER_CLONE (self)->priv; ClutterActorBox box, source_box; gfloat x_scale, y_scale; /* First chain up and apply all the standard ClutterActor * transformations... */ CLUTTER_ACTOR_CLASS (clutter_clone_parent_class)->apply_transform (self, matrix); /* if we don't have a source, nothing else to do */ if (priv->clone_source == NULL) return; /* get our allocated size */ clutter_actor_get_allocation_box (self, &box); /* and get the allocated size of the source */ clutter_actor_get_allocation_box (priv->clone_source, &source_box); /* We need to scale what the clone-source actor paints to fill our own * allocation... */ x_scale = clutter_actor_box_get_width (&box) / clutter_actor_box_get_width (&source_box); y_scale = clutter_actor_box_get_height (&box) / clutter_actor_box_get_height (&source_box); cogl_matrix_scale (matrix, x_scale, y_scale, x_scale); }
static void mx_progress_bar_allocate_fill (MxProgressBar *self, const ClutterActorBox *box, ClutterAllocationFlags flags) { ClutterActorBox box_data; MxProgressBarPrivate *priv = self->priv; if (!box) { clutter_actor_get_allocation_box (CLUTTER_ACTOR (self), &box_data); box = &box_data; } if (priv->progress) { ClutterActorBox child_box; MxPadding padding; mx_widget_get_padding (MX_WIDGET (self), &padding); child_box.x1 = padding.left; child_box.y1 = padding.top; child_box.y2 = (box->y2 - box->y1) - padding.bottom; child_box.x2 = ((box->x2 - box->x1 - padding.left - padding.right) * priv->progress) + padding.left; clutter_actor_allocate (priv->fill, &child_box, flags); } }
static void st_icon_paint (ClutterActor *actor) { StIconPrivate *priv = ST_ICON (actor)->priv; /* Chain up to paint background */ CLUTTER_ACTOR_CLASS (st_icon_parent_class)->paint (actor); if (priv->icon_texture) { if (priv->shadow_material) { ClutterActorBox allocation; float width, height; clutter_actor_get_allocation_box (priv->icon_texture, &allocation); clutter_actor_box_get_size (&allocation, &width, &height); allocation.x1 = (width - priv->shadow_width) / 2; allocation.y1 = (height - priv->shadow_height) / 2; allocation.x2 = allocation.x1 + priv->shadow_width; allocation.y2 = allocation.y1 + priv->shadow_height; _st_paint_shadow_with_opacity (priv->shadow_spec, priv->shadow_material, &allocation, clutter_actor_get_paint_opacity (priv->icon_texture)); } clutter_actor_paint (priv->icon_texture); } }
static void glide_image_paint (ClutterActor *self) { GlideImage *image = GLIDE_IMAGE (self); GlideImagePrivate *priv = image->priv; ClutterActorBox box = {0, }; gfloat t_w, t_h; guint8 paint_opacity = clutter_actor_get_paint_opacity (self); if (paint_opacity == 0) { return; } GLIDE_NOTE (PAINT, "painting image '%s'", GLIDE_ACTOR_DISPLAY_NAME (self)); cogl_material_set_color4ub (priv->material, paint_opacity, paint_opacity, paint_opacity, paint_opacity); clutter_actor_get_allocation_box (self, &box); GLIDE_NOTE (PAINT, "paint to x1: %f, y1: %f x2: %f, y2: %f " "opacity: %i", box.x1, box.y1, box.x2, box.y2, clutter_actor_get_opacity (self)); t_w = 1.0; t_h = 1.0; cogl_set_source (priv->material); cogl_rectangle_with_texture_coords (0, 0, box.x2 - box.x1, box.y2 - box.y1, 0, 0, t_w, t_h); }
void clarity_cover_set_album_item (ClarityCover *self, AlbumItem *item) { g_return_if_fail(CLARITY_IS_COVER(self)); ClarityCoverPrivate *priv = CLARITY_COVER_GET_PRIVATE (self); g_return_if_fail(priv); GError *error = NULL; gint y_offset; if (!priv->texture) { priv->texture = gtk_clutter_texture_new(); clutter_container_add_actor(CLUTTER_CONTAINER(self), priv->texture); } // Set cover artwork gtk_clutter_texture_set_from_pixbuf (GTK_CLUTTER_TEXTURE(priv->texture), item->albumart, &error); if (error) { g_warning("%s", error->message); g_error_free(error); return; } // Add reflection if (! priv->reflection) { y_offset = clutter_actor_get_height (priv->texture) + V_PADDING; priv->reflection = clutter_clone_new (priv->texture); clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_X, 0.0)); clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_Y, y_offset)); clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_WIDTH, 0.0)); clutter_actor_add_constraint (priv->reflection, clutter_bind_constraint_new (priv->texture, CLUTTER_BIND_HEIGHT, 0.0)); g_signal_connect (priv->reflection, "paint", G_CALLBACK (_clone_paint_cb), NULL); clutter_container_add_actor(CLUTTER_CONTAINER(self), priv->reflection); } ClutterActorBox box; gfloat w, h; clutter_actor_get_allocation_box (priv->texture, &box); clutter_actor_box_get_size (&box, &w, &h); if( h > DEFAULT_IMG_SIZE) { gfloat temp = w * DEFAULT_IMG_SIZE / h; clutter_actor_set_size(priv->texture, temp, DEFAULT_IMG_SIZE); } // Add title / artist data if (priv->title) g_free(priv->title); priv->title = g_strdup(item->albumname); if (priv->artist) g_free(priv->artist); priv->artist = g_strdup(item->artist); }
static void actor_show_cb (ClutterActor *actor, MnbInputLayer layer) { ClutterActorBox box; MnbInputRegion *mir = g_object_get_qdata (G_OBJECT (actor), quark_mir); Display *xdpy; g_assert (mgr_singleton); xdpy = meta_plugin_get_xdisplay (mgr_singleton->plugin); clutter_actor_get_allocation_box (actor, &box); if (!mir) { mir = mnb_input_manager_push_region (box.x1, box.y1, box.x2 - box.x1, box.y2 - box.y1, META_IS_WINDOW_ACTOR (actor), layer); g_object_set_qdata (G_OBJECT (actor), quark_mir, mir); } else { XRectangle rect; rect.x = box.x1; rect.y = box.y1; rect.width = box.x2 - box.x1; rect.height = box.y2 - box.y1; XFixesSetRegion (xdpy, mir->region, &rect, 1); mnb_input_manager_apply_stack (); } }
/* 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); } }
static void key_group_paint (ClutterActor *actor) { KeyGroup *self = KEY_GROUP (actor); GList *children, *l; gint i; children = clutter_container_get_children (CLUTTER_CONTAINER (self)); for (l = children, i = 0; l != NULL; l = l->next, i++) { ClutterActor *child = l->data; /* paint the selection rectangle */ if (i == self->selected_index) { ClutterActorBox box = { 0, }; clutter_actor_get_allocation_box (child, &box); box.x1 -= 2; box.y1 -= 2; box.x2 += 2; box.y2 += 2; cogl_set_source_color4ub (255, 255, 0, 224); cogl_rectangle (box.x1, box.y1, box.x2, box.y2); } clutter_actor_paint (child); } g_list_free (children); }
/*<private> * _clutter_actor_set_default_paint_volume: * @self: a #ClutterActor * @check_gtype: if not %G_TYPE_INVALID, match the type of @self against * this type * @volume: the #ClutterPaintVolume to set * * Sets the default paint volume for @self. * * This function should be called by #ClutterActor sub-classes that follow * the default assumption that their paint volume is defined by their * allocation. * * If @check_gtype is not %G_TYPE_INVALID, this function will check the * type of @self and only compute the paint volume if the type matches; * this can be used to avoid computing the paint volume for sub-classes * of an actor class * * Return value: %TRUE if the paint volume was set, and %FALSE otherwise */ gboolean _clutter_actor_set_default_paint_volume (ClutterActor *self, GType check_gtype, ClutterPaintVolume *volume) { ClutterActorBox box; if (check_gtype != G_TYPE_INVALID) { if (G_OBJECT_TYPE (self) != check_gtype) return FALSE; } /* calling clutter_actor_get_allocation_* can potentially be very * expensive, as it can result in a synchronous full stage relayout * and redraw */ if (!clutter_actor_has_allocation (self)) return FALSE; clutter_actor_get_allocation_box (self, &box); /* we only set the width and height, as the paint volume is defined * to be relative to the actor's modelview, which means that the * allocation's origin has already been applied */ clutter_paint_volume_set_width (volume, box.x2 - box.x1); clutter_paint_volume_set_height (volume, box.y2 - box.y1); return TRUE; }
static void clutter_box_real_paint (ClutterActor *actor) { ClutterBoxPrivate *priv = CLUTTER_BOX (actor)->priv; if (priv->color_set) { ClutterActorBox box = { 0, }; gfloat width, height; guint8 tmp_alpha; clutter_actor_get_allocation_box (actor, &box); clutter_actor_box_get_size (&box, &width, &height); tmp_alpha = clutter_actor_get_paint_opacity (actor) * priv->color.alpha / 255; cogl_set_source_color4ub (priv->color.red, priv->color.green, priv->color.blue, tmp_alpha); cogl_rectangle (0, 0, width, height); } g_list_foreach (priv->children, (GFunc) clutter_actor_paint, NULL); }
static void st_icon_paint (ClutterActor *actor) { StIconPrivate *priv = ST_ICON (actor)->priv; st_widget_paint_background (ST_WIDGET (actor)); if (priv->icon_texture) { if (priv->shadow_material) { ClutterActorBox allocation; float width, height; clutter_actor_get_allocation_box (priv->icon_texture, &allocation); clutter_actor_box_get_size (&allocation, &width, &height); _st_paint_shadow_with_opacity (priv->shadow_spec, priv->shadow_material, &allocation, clutter_actor_get_paint_opacity (priv->icon_texture)); } clutter_actor_paint (priv->icon_texture); } }
/* Allocation of a view changed */ static void _xfdashboard_viewpad_update_scrollbars(XfdashboardViewpad *self) { XfdashboardViewpadPrivate *priv; gfloat w, h; g_return_if_fail(XFDASHBOARD_IS_VIEWPAD(self)); priv=self->priv; /* Set range of scroll bar to width and height of active view * But we need to check for nan-values here - I do not get rid of it :( */ if(priv->activeView) clutter_actor_get_size(CLUTTER_ACTOR(priv->activeView), &w, &h); else w=h=1.0f; xfdashboard_scrollbar_set_range(XFDASHBOARD_SCROLLBAR(priv->hScrollbar), isnan(w)==0 ? w : 0.0f); xfdashboard_scrollbar_set_range(XFDASHBOARD_SCROLLBAR(priv->vScrollbar), isnan(h)==0 ? h : 0.0f); /* If any scroll bar policy is automatic then reallocate the * same allocation again in an unkindly way to force a recalculation * if scroll bars needed to shown (or hidden what is unlikely) */ if(CLUTTER_ACTOR_IS_VISIBLE(self) && (priv->hScrollbarPolicy==XFDASHBOARD_POLICY_AUTOMATIC || priv->vScrollbarPolicy==XFDASHBOARD_POLICY_AUTOMATIC)) { ClutterActorBox box; clutter_actor_get_allocation_box(CLUTTER_ACTOR(self), &box); _xfdashboard_viewpad_allocate(CLUTTER_ACTOR(self), &box, CLUTTER_DELEGATE_LAYOUT); } }
static void mex_column_pick (ClutterActor *actor, const ClutterColor *color) { GList *c; gdouble value; MxPadding padding; ClutterActorBox box; MexColumn *self = MEX_COLUMN (actor); MexColumnPrivate *priv = self->priv; CLUTTER_ACTOR_CLASS (mex_column_parent_class)->pick (actor, color); /* Don't pick children when we don't have focus */ if (!priv->has_focus) return; mx_widget_get_padding (MX_WIDGET (actor), &padding); clutter_actor_get_allocation_box (actor, &box); if (priv->adjustment) value = priv->adjustment_value; else value = 0; cogl_clip_push_rectangle (padding.left, padding.top + value, box.x2 - box.x1 - padding.right, box.y2 - box.y1 - padding.bottom + value); for (c = priv->children; c; c = c->next) clutter_actor_paint (c->data); cogl_clip_pop (); }
static void empathy_rounded_effect_paint (ClutterEffect *effect, ClutterEffectPaintFlags flags) { EmpathyRoundedEffect *self = EMPATHY_ROUNDED_EFFECT (effect); ClutterActor *actor; ClutterActorBox allocation = { 0, }; gfloat width, height; actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (self)); clutter_actor_get_allocation_box (actor, &allocation); clutter_actor_box_get_size (&allocation, &width, &height); cogl_path_new (); /* Create and store a path describing a rounded rectangle. The small * size of the preview window makes the radius of the rounded corners * very small too, so we can safely use a very coarse angle step * without loosing rendering accuracy. It also significantly reduces * the time spent in the underlying internal cogl path functions */ cogl_path_round_rectangle (0, 0, width, height, height / 16., 15); cogl_clip_push_from_path (); /* Flip */ cogl_push_matrix (); cogl_translate (width, 0, 0); cogl_scale (-1, 1, 1); clutter_actor_continue_paint (actor); cogl_pop_matrix (); cogl_clip_pop (); }
static void actor_allocation_cb (ClutterActor *actor, GParamSpec *pspec, gpointer data) { ClutterActorBox box; MnbInputRegion *mir = g_object_get_qdata (G_OBJECT (actor), quark_mir); XRectangle rect; Display *xdpy; g_assert (mgr_singleton); if (!mir) return; xdpy = meta_plugin_get_xdisplay (mgr_singleton->plugin); clutter_actor_get_allocation_box (actor, &box); rect.x = box.x1; rect.y = box.y1; rect.width = box.x2 - box.x1; rect.height = box.y2 - box.y1; XFixesSetRegion (xdpy, mir->region, &rect, 1); mnb_input_manager_apply_stack (); }
static void mex_shell_add (ClutterContainer *container, ClutterActor *actor) { ClutterActorBox box; MexShellChildData *data; MexShell *self = MEX_SHELL (container); MexShellPrivate *priv = self->priv; data = mex_shell_child_data_new (self, actor); priv->children = g_list_append (priv->children, data); clutter_actor_set_parent (actor, CLUTTER_ACTOR (container)); clutter_actor_set_opacity (actor, 0x00); clutter_actor_get_allocation_box (CLUTTER_ACTOR (container), &box); data->target_width = box.x2 - box.x1; data->target_height = box.y2 - box.y1; g_object_set (G_OBJECT (actor), "natural-width", data->target_width, "natural-height", data->target_height, NULL); g_signal_emit_by_name (container, "actor-added", actor); }
/* Dump actors */ static void _xfdashboard_dump_actor_print(ClutterActor *inActor, gint inLevel) { XfdashboardStylable *stylable; ClutterActorBox allocation; gint i; g_return_if_fail(CLUTTER_IS_ACTOR(inActor)); g_return_if_fail(inLevel>=0); /* Check if actor is stylable to retrieve style configuration */ stylable=NULL; if(XFDASHBOARD_IS_STYLABLE(inActor)) stylable=XFDASHBOARD_STYLABLE(inActor); /* Dump actor */ for(i=0; i<inLevel; i++) g_print(" "); clutter_actor_get_allocation_box(inActor, &allocation); g_print("+- %s@%p [%s%s%s%s%s%s] - geometry: %.2f,%.2f [%.2fx%.2f], mapped: %s, visible: %s, layout: %s, children: %d\n", G_OBJECT_TYPE_NAME(inActor), inActor, clutter_actor_get_name(inActor) ? " #" : "", clutter_actor_get_name(inActor) ? clutter_actor_get_name(inActor) : "", stylable && xfdashboard_stylable_get_classes(stylable) ? "." : "", stylable && xfdashboard_stylable_get_classes(stylable) ? xfdashboard_stylable_get_classes(stylable) : "", stylable && xfdashboard_stylable_get_pseudo_classes(stylable) ? ":" : "", stylable && xfdashboard_stylable_get_pseudo_classes(stylable) ? xfdashboard_stylable_get_pseudo_classes(stylable) : "", allocation.x1, allocation.y1, allocation.x2-allocation.x1, allocation.y2-allocation.y1, clutter_actor_is_mapped(inActor) ? "yes" : "no", clutter_actor_is_visible(inActor) ? "yes" : "no", clutter_actor_get_layout_manager(inActor) ? G_OBJECT_TYPE_NAME(clutter_actor_get_layout_manager(inActor)) : "none", clutter_actor_get_n_children(inActor)); }
static gboolean mx_toggle_handle_button_release_event (ClutterActor *actor, ClutterButtonEvent *event, MxToggle *toggle) { ClutterActorBox box; if (mx_widget_get_disabled (MX_WIDGET (toggle))) return FALSE; if (toggle->priv->last_move == 0) mx_toggle_set_active (toggle, !toggle->priv->active); else mx_toggle_set_active (toggle, (toggle->priv->last_move > 0.0)); toggle->priv->drag_offset = -1; toggle->priv->last_move = 0; clutter_ungrab_pointer (); /* ensure the hover state is removed if the pointer left the handle * during the grab */ clutter_actor_get_allocation_box (actor, &box); if (!clutter_actor_box_contains (&box, event->x, event->y)) mx_stylable_style_pseudo_class_remove (MX_STYLABLE (actor), "hover"); return TRUE; }
static void mex_column_paint (ClutterActor *actor) { GList *c; MxPadding padding; ClutterActorBox box; MexColumn *self = MEX_COLUMN (actor); MexColumnPrivate *priv = self->priv; CLUTTER_ACTOR_CLASS (mex_column_parent_class)->paint (actor); mx_widget_get_padding (MX_WIDGET (actor), &padding); clutter_actor_get_allocation_box (actor, &box); cogl_clip_push_rectangle (padding.left, padding.top + priv->adjustment_value, box.x2 - box.x1 - padding.right, box.y2 - box.y1 - padding.bottom + priv->adjustment_value); for (c = priv->children; c; c = c->next) { /* skip the current focus and paint it last*/ if (priv->current_focus != c->data) clutter_actor_paint (c->data); } /* paint the current focused actor last to ensure any shadow is drawn * on top of other items */ if (priv->current_focus) clutter_actor_paint (priv->current_focus); cogl_clip_pop (); }
static void mx_slider_allocate (ClutterActor *actor, const ClutterActorBox *box, ClutterAllocationFlags flags) { MxSlider *self = MX_SLIDER (actor); MxSliderPrivate *priv = self->priv; MxPadding padding; ClutterActorClass *actor_class; ClutterActorBox bar_box; ClutterActorBox trough_box; guint handle_width_2; actor_class = CLUTTER_ACTOR_CLASS (mx_slider_parent_class); actor_class->allocate (actor, box, flags); if (box == NULL) { clutter_actor_get_allocation_box (CLUTTER_ACTOR (self), &bar_box); box = &bar_box; } handle_width_2 = priv->handle_width >> 1; mx_widget_get_padding (MX_WIDGET (self), &padding); /* save the min/max position of the middle of the handle */ priv->handle_middle_start = padding.left + handle_width_2 + 1; priv->handle_middle_end = box->x2 - box->x1 - padding.right - handle_width_2 - 1; if (priv->trough_height < 0) { /* trough-height has not been specified, take the whole height */ trough_box.x1 = padding.left; trough_box.y1 = padding.top; trough_box.x2 = (box->x2 - box->x1) - padding.right; trough_box.y2 = (box->y2 - box->y1) - padding.bottom; } else { trough_box.x1 = padding.left; trough_box.y1 = (int) ((box->y2 - box->y1 - padding.bottom - padding.top - priv->trough_height) / 2); trough_box.x2 = (box->x2 - box->x1) - padding.right; trough_box.y2 = trough_box.y1 + priv->trough_height; } clutter_actor_allocate (priv->trough_bg, &trough_box, flags); /* save trough_box.y1 and trough_box.y2 so we don't have the duplicate * the logic above in ::allocate_fill() */ priv->trough_box_y1 = trough_box.y1; priv->trough_box_y2 = trough_box.y2; mx_slider_allocate_fill_handle (self, box, flags); clutter_actor_allocate (priv->trough, &trough_box, flags); }
/* filter @children to contain only only actors that overlap @rbox * when moving in @direction. (Assuming no transformations.) */ static GList * filter_by_position (GList *children, ClutterActorBox *rbox, GtkDirectionType direction) { ClutterActorBox cbox; GList *l, *ret; ClutterActor *child; for (l = children, ret = NULL; l; l = l->next) { child = l->data; clutter_actor_get_allocation_box (child, &cbox); /* Filter out children if they are in the wrong direction from * @rbox, or if they don't overlap it. To account for floating- * point imprecision, an actor is "down" (etc.) from an another * actor even if it overlaps it by up to 0.1 pixels. */ switch (direction) { case GTK_DIR_UP: if (cbox.y2 > rbox->y1 + 0.1) continue; if (cbox.x1 >= rbox->x2 || cbox.x2 <= rbox->x1) continue; break; case GTK_DIR_DOWN: if (cbox.y1 < rbox->y2 - 0.1) continue; if (cbox.x1 >= rbox->x2 || cbox.x2 <= rbox->x1) continue; break; case GTK_DIR_LEFT: if (cbox.x2 > rbox->x1 + 0.1) continue; if (cbox.y1 >= rbox->y2 || cbox.y2 <= rbox->y1) continue; break; case GTK_DIR_RIGHT: if (cbox.x1 < rbox->x2 - 0.1) continue; if (cbox.y1 >= rbox->y2 || cbox.y2 <= rbox->y1) continue; break; default: g_return_val_if_reached (NULL); } ret = g_list_prepend (ret, child); } g_list_free (children); return ret; }
static void mex_grid_view_get_current_target (MexScene *scene, ClutterActorBox *box) { MexGridViewPrivate *priv = MEX_GRID_VIEW (scene)->priv; clutter_actor_get_allocation_box (CLUTTER_ACTOR (priv->menu_layout), box); }
static void st_box_layout_paint (ClutterActor *actor) { StBoxLayout *self = ST_BOX_LAYOUT (actor); StBoxLayoutPrivate *priv = self->priv; StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor)); GList *l, *children; gdouble x, y; ClutterActorBox allocation_box; ClutterActorBox content_box; get_border_paint_offsets (self, &x, &y); if (x != 0 || y != 0) { cogl_push_matrix (); cogl_translate ((int)x, (int)y, 0); } CLUTTER_ACTOR_CLASS (st_box_layout_parent_class)->paint (actor); if (x != 0 || y != 0) { cogl_pop_matrix (); } children = st_container_get_children_list (ST_CONTAINER (actor)); if (children == NULL) return; clutter_actor_get_allocation_box (actor, &allocation_box); st_theme_node_get_content_box (theme_node, &allocation_box, &content_box); content_box.x1 += x; content_box.y1 += y; content_box.x2 += x; content_box.y2 += y; /* The content area forms the viewport into the scrolled contents, while * the borders and background stay in place; after drawing the borders and * background, we clip to the content area */ if (priv->hadjustment || priv->vadjustment) cogl_clip_push_rectangle ((int)content_box.x1, (int)content_box.y1, (int)content_box.x2, (int)content_box.y2); for (l = children; l; l = g_list_next (l)) { ClutterActor *child = (ClutterActor*) l->data; if (CLUTTER_ACTOR_IS_VISIBLE (child)) clutter_actor_paint (child); } if (priv->hadjustment || priv->vadjustment) cogl_clip_pop (); }
CoglHandle _st_create_shadow_material_from_actor (StShadow *shadow_spec, ClutterActor *actor) { CoglHandle shadow_material = COGL_INVALID_HANDLE; if (CLUTTER_IS_TEXTURE (actor)) { CoglHandle texture; texture = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (actor)); shadow_material = _st_create_shadow_material (shadow_spec, texture); } else { CoglHandle buffer, offscreen; ClutterActorBox box; CoglColor clear_color; float width, height; clutter_actor_get_allocation_box (actor, &box); clutter_actor_box_get_size (&box, &width, &height); if (width == 0 || height == 0) return COGL_INVALID_HANDLE; buffer = st_cogl_texture_new_with_size_wrapper (width, height, COGL_TEXTURE_NO_SLICING, COGL_PIXEL_FORMAT_ANY); if (buffer == COGL_INVALID_HANDLE) return COGL_INVALID_HANDLE; offscreen = cogl_offscreen_new_to_texture (buffer); if (offscreen == COGL_INVALID_HANDLE) { cogl_handle_unref (buffer); return COGL_INVALID_HANDLE; } cogl_color_set_from_4ub (&clear_color, 0, 0, 0, 0); cogl_push_framebuffer (offscreen); cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR); cogl_translate (-box.x1, -box.y1, 0); cogl_ortho (0, width, height, 0, 0, 1.0); clutter_actor_paint (actor); cogl_pop_framebuffer (); cogl_handle_unref (offscreen); shadow_material = _st_create_shadow_material (shadow_spec, buffer); cogl_handle_unref (buffer); } return shadow_material; }
static void mex_grid_view_paint (ClutterActor *actor) { MexGridViewPrivate *priv = MEX_GRID_VIEW (actor)->priv; ClutterActorBox gbox, mbox; CLUTTER_ACTOR_CLASS (mex_grid_view_parent_class)->paint (actor); clutter_actor_get_allocation_box (priv->menu_layout, &mbox); clutter_actor_get_allocation_box (priv->grid_layout, &gbox); cogl_clip_push_rectangle (mbox.x2, mbox.y1, gbox.x2, gbox.y2); clutter_actor_paint (priv->grid_layout); cogl_clip_pop (); clutter_actor_paint (priv->menu_layout); }
static void mex_tile_paint (ClutterActor *actor) { MexTilePrivate *priv = MEX_TILE (actor)->priv; MxPadding padding; ClutterActorBox box; CLUTTER_ACTOR_CLASS (mex_tile_parent_class)->paint (actor); clutter_actor_paint (priv->child); mx_widget_get_padding (MX_WIDGET (actor), &padding); if (priv->header_visible) { clutter_actor_get_allocation_box (actor, &box); if (priv->header_background_color) { cogl_set_source_color4ub (priv->header_background_color->red, priv->header_background_color->green, priv->header_background_color->blue, priv->header_background_color->alpha); cogl_rectangle (padding.left, padding.top, box.x2 - box.x1 - padding.right, priv->header_height); } if (cogl_material_get_n_layers (priv->material) > 0) { guint8 opacity; opacity = clutter_actor_get_paint_opacity (actor); cogl_material_set_color4ub (priv->material, opacity, opacity, opacity, opacity); cogl_set_source (priv->material); cogl_rectangle (padding.left, padding.top, box.x2 - box.x1 - padding.right, priv->header_height); } clutter_actor_paint (priv->box_layout); if (priv->icon1) clutter_actor_paint (priv->icon1); if (priv->icon2) clutter_actor_paint (priv->icon2); } }
static void st_box_layout_paint (ClutterActor *actor) { StBoxLayout *self = ST_BOX_LAYOUT (actor); StBoxLayoutPrivate *priv = self->priv; StThemeNode *theme_node = st_widget_get_theme_node (ST_WIDGET (actor)); gdouble x, y; ClutterActorBox allocation_box; ClutterActorBox content_box; ClutterActor *child; get_border_paint_offsets (self, &x, &y); if (x != 0 || y != 0) { cogl_push_matrix (); cogl_translate ((int)x, (int)y, 0); } st_widget_paint_background (ST_WIDGET (actor)); if (x != 0 || y != 0) { cogl_pop_matrix (); } if (clutter_actor_get_n_children (actor) == 0) return; clutter_actor_get_allocation_box (actor, &allocation_box); st_theme_node_get_content_box (theme_node, &allocation_box, &content_box); content_box.x1 += x; content_box.y1 += y; content_box.x2 += x; content_box.y2 += y; /* The content area forms the viewport into the scrolled contents, while * the borders and background stay in place; after drawing the borders and * background, we clip to the content area */ if (priv->hadjustment || priv->vadjustment) cogl_clip_push_rectangle ((int)content_box.x1, (int)content_box.y1, (int)content_box.x2, (int)content_box.y2); for (child = clutter_actor_get_first_child (actor); child != NULL; child = clutter_actor_get_next_sibling (child)) clutter_actor_paint (child); if (priv->hadjustment || priv->vadjustment) cogl_clip_pop (); }
static gboolean shell_generic_container_get_paint_volume (ClutterActor *self, ClutterPaintVolume *volume) { ClutterActorBox paint_box, alloc_box; StThemeNode *theme_node; ClutterVertex origin; /* Setting the paint volume does not make sense when we don't have any allocation */ if (!clutter_actor_has_allocation (self)) return FALSE; theme_node = st_widget_get_theme_node (ST_WIDGET (self)); clutter_actor_get_allocation_box (self, &alloc_box); st_theme_node_get_paint_box (theme_node, &alloc_box, &paint_box); origin.x = paint_box.x1 - alloc_box.x1; origin.y = paint_box.y1 - alloc_box.y1; origin.z = 0.0f; clutter_paint_volume_set_origin (volume, &origin); clutter_paint_volume_set_width (volume, paint_box.x2 - paint_box.x1); clutter_paint_volume_set_height (volume, paint_box.y2 - paint_box.y1); if (!clutter_actor_get_clip_to_allocation (self)) { ClutterActor *child; /* Based on ClutterGroup/ClutterBox; include the children's * paint volumes, since they may paint outside our allocation. */ for (child = clutter_actor_get_first_child (self); child != NULL; child = clutter_actor_get_next_sibling (child)) { const ClutterPaintVolume *child_volume; if (!CLUTTER_ACTOR_IS_VISIBLE (child)) continue; if (shell_generic_container_get_skip_paint (SHELL_GENERIC_CONTAINER (self), child)) continue; child_volume = clutter_actor_get_transformed_paint_volume (child, self); if (!child_volume) return FALSE; clutter_paint_volume_union (volume, child_volume); } } return TRUE; }
static void penge_magic_texture_paint (ClutterActor *actor) { ClutterActorBox box; CoglHandle *material, *tex; float bw, bh; float aw, ah; float v; float tx1, tx2, ty1, ty2; guint8 alpha; clutter_actor_get_allocation_box (actor, &box); material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (actor)); tex = clutter_texture_get_cogl_texture (CLUTTER_TEXTURE (actor)); bw = (float) cogl_texture_get_width (tex); /* base texture width */ bh = (float) cogl_texture_get_height (tex); /* base texture height */ aw = (float) (box.x2 - box.x1); /* allocation width */ ah = (float) (box.y2 - box.y1); /* allocation height */ /* no comment */ if ((float)bw/bh < (float)aw/ah) { /* fit width */ v = (((float)ah * bw) / ((float)aw * bh)) / 2; tx1 = 0; tx2 = 1; ty1 = (0.5 - v); ty2 = (0.5 + v); } else { /* fit height */ v = (((float)aw * bh) / ((float)ah * bw)) / 2; tx1 = (0.5 - v); tx2 = (0.5 + v); ty1 = 0; ty2 = 1; } alpha = clutter_actor_get_paint_opacity (actor); cogl_material_set_color4ub (material, alpha, alpha, alpha, alpha); cogl_set_source (material); cogl_rectangle_with_texture_coords (0, 0, aw, ah, tx1, ty1, tx2, ty2); }