static void tile_focus_in_cb (MxBin *actor) { ClutterActorMeta *shadow; shadow = (ClutterActorMeta*) clutter_actor_get_effect (CLUTTER_ACTOR (actor), "shadow"); clutter_actor_meta_set_enabled (shadow, TRUE); shadow = (ClutterActorMeta*) clutter_actor_get_effect (mx_bin_get_child (actor), "shadow"); clutter_actor_meta_set_enabled (shadow, FALSE); }
static void content_box_open_notify (MexContentBox *box, GParamSpec *pspec, MexColumn *column) { MexColumnPrivate *priv = MEX_COLUMN (column)->priv; GList *l; ClutterActorMeta *shadow; if (mex_content_box_get_open (box)) { for (l = priv->children; l; l = l->next) { if (l->data != box) clutter_actor_animate (l->data, CLUTTER_EASE_IN_OUT_QUAD, 200, "opacity", 56, NULL); } shadow = (ClutterActorMeta*) clutter_actor_get_effect (CLUTTER_ACTOR (box), "shadow"); clutter_actor_meta_set_enabled (shadow, TRUE); /* Restore the opened box to full opacity */ clutter_actor_animate (CLUTTER_ACTOR (box), CLUTTER_EASE_IN_OUT_QUAD, 200, "opacity", 255, NULL); priv->open_boxes ++; } else { priv->open_boxes --; } if (priv->open_boxes == 0) { /* restore all children to full opacity */ for (l = priv->children; l; l = l->next) { clutter_actor_animate (l->data, CLUTTER_EASE_IN_OUT_QUAD, 200, "opacity", 255, NULL); } shadow = (ClutterActorMeta*) clutter_actor_get_effect (CLUTTER_ACTOR (box), "shadow"); clutter_actor_meta_set_enabled (shadow, FALSE); } g_object_notify (G_OBJECT (column), "opened"); }
static void clutter_shader_effect_set_actor (ClutterActorMeta *meta, ClutterActor *actor) { ClutterShaderEffect *self = CLUTTER_SHADER_EFFECT (meta); ClutterShaderEffectPrivate *priv = self->priv; ClutterActorMetaClass *parent; if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL)) { /* if we don't have support for GLSL shaders then we * forcibly disable the ActorMeta */ g_warning ("Unable to use the ShaderEffect: the graphics hardware " "or the current GL driver does not implement support " "for the GLSL shading language."); clutter_actor_meta_set_enabled (meta, FALSE); return; } parent = CLUTTER_ACTOR_META_CLASS (clutter_shader_effect_parent_class); parent->set_actor (meta, actor); /* we keep a back pointer here */ priv->actor = clutter_actor_meta_get_actor (meta); if (priv->actor == NULL) return; CLUTTER_NOTE (SHADER, "Preparing shader effect of type '%s'", G_OBJECT_TYPE_NAME (meta)); }
static void mx_label_fade_started_cb (ClutterTimeline *timeline, MxLabel *label) { clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (label->priv->fade_effect), TRUE); }
static void mex_tile_init (MexTile *self) { MexTilePrivate *priv = self->priv = TILE_PRIVATE (self); const ClutterColor opaque = { 0x00, 0x00, 0x00, 0x00 }; ClutterEffect *fade; /* create a template material for the header background from which cheap * copies can be made for each instance */ if (G_UNLIKELY (!template_material)) template_material = cogl_material_new (); priv->material = cogl_material_copy (template_material); /* layout for primary and secondary labels */ priv->box_layout = mx_box_layout_new (); mx_box_layout_set_spacing (MX_BOX_LAYOUT (priv->box_layout), 12); /* add fade effect to the box layout */ fade = (ClutterEffect*) mx_fade_effect_new (); mx_fade_effect_set_border (MX_FADE_EFFECT (fade), 0, 50, 0, 0); mx_fade_effect_set_color (MX_FADE_EFFECT (fade), &opaque); clutter_actor_add_effect_with_name (priv->box_layout, "fade", fade); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (fade), TRUE); clutter_actor_push_internal (CLUTTER_ACTOR (self)); clutter_actor_set_parent (priv->box_layout, CLUTTER_ACTOR (self)); clutter_actor_pop_internal (CLUTTER_ACTOR (self)); priv->label = clutter_text_new (); priv->secondary_label = clutter_text_new (); clutter_actor_set_opacity (priv->secondary_label, 128); clutter_container_add (CLUTTER_CONTAINER (priv->box_layout), priv->label, priv->secondary_label, NULL); priv->header_visible = TRUE; priv->timeline = clutter_timeline_new (DURATION); priv->important_alpha = clutter_alpha_new_full (priv->timeline, CLUTTER_EASE_OUT_QUAD); g_signal_connect_object (priv->timeline, "new-frame", G_CALLBACK (mex_tile_important_new_frame_cb), self, 0); g_signal_connect_object (priv->timeline, "completed", G_CALLBACK (mex_tile_timeline_completed_cb), self, 0); g_signal_connect (self, "style-changed", G_CALLBACK (mex_tile_style_changed_cb), NULL); g_signal_connect (self, "actor-added", G_CALLBACK (mex_tile_actor_added), NULL); g_signal_connect (self, "actor-removed", G_CALLBACK (mex_tile_actor_removed), NULL); }
static void st_scroll_view_fade_set_actor (ClutterActorMeta *meta, ClutterActor *actor) { StScrollViewFade *self = ST_SCROLL_VIEW_FADE (meta); ClutterActorMetaClass *parent; g_return_if_fail (actor == NULL || ST_IS_SCROLL_VIEW (actor)); if (self->shader == COGL_INVALID_HANDLE) { clutter_actor_meta_set_enabled (meta, FALSE); return; } if (self->vadjustment) { g_signal_handlers_disconnect_by_func (self->vadjustment, (gpointer)on_adjustment_changed, self); self->vadjustment = NULL; } if (self->hadjustment) { g_signal_handlers_disconnect_by_func (self->hadjustment, (gpointer)on_adjustment_changed, self); self->hadjustment = NULL; } if (actor) { StScrollView *scroll_view = ST_SCROLL_VIEW (actor); StScrollBar *vscroll = ST_SCROLL_BAR (st_scroll_view_get_vscroll_bar (scroll_view)); StScrollBar *hscroll = ST_SCROLL_BAR (st_scroll_view_get_hscroll_bar (scroll_view)); self->vadjustment = ST_ADJUSTMENT (st_scroll_bar_get_adjustment (vscroll)); self->hadjustment = ST_ADJUSTMENT (st_scroll_bar_get_adjustment (hscroll)); g_signal_connect (self->vadjustment, "changed", G_CALLBACK (on_adjustment_changed), self); g_signal_connect (self->hadjustment, "changed", G_CALLBACK (on_adjustment_changed), self); on_adjustment_changed (NULL, CLUTTER_EFFECT (self)); } parent = CLUTTER_ACTOR_META_CLASS (st_scroll_view_fade_parent_class); parent->set_actor (meta, actor); /* we keep a back pointer here, to avoid going through the ActorMeta */ self->actor = clutter_actor_meta_get_actor (meta); }
static void mx_label_fade_completed_cb (ClutterTimeline *timeline, MxLabel *label) { MxLabelPrivate *priv = label->priv; if (!priv->label_should_fade) clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (priv->fade_effect), FALSE); }
static void on_vadjustment_changed (StAdjustment *adjustment, ClutterEffect *effect) { gdouble value, lower, upper, page_size; gboolean needs_fade; st_adjustment_get_values (adjustment, &value, &lower, &upper, NULL, NULL, &page_size); needs_fade = (value > lower + 0.1) || (value < upper - page_size - 0.1); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), needs_fade); }
static MxFocusable * _accept_focus (MxFocusable *focusable, MxFocusHint hint) { MexActionButtonPrivate *priv = MEX_ACTION_BUTTON (focusable)->priv; MxFocusableIface *iface; priv->has_focus = TRUE; clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (priv->shadow), TRUE); iface = g_type_interface_peek_parent (MX_FOCUSABLE_GET_INTERFACE (focusable)); return iface->accept_focus (focusable, hint); }
static MxFocusable * _move_focus (MxFocusable *focusable, MxFocusDirection direction, MxFocusable *old_focus) { MexActionButtonPrivate *priv = MEX_ACTION_BUTTON (focusable)->priv; MxFocusableIface *iface; clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (priv->shadow), FALSE); priv->has_focus = FALSE; iface = g_type_interface_peek_parent (MX_FOCUSABLE_GET_INTERFACE (focusable)); return iface->move_focus (focusable, direction, old_focus); }
static void on_adjustment_changed (StAdjustment *adjustment, ClutterEffect *effect) { gdouble value, lower, upper, page_size; gboolean needs_fade; StScrollViewFade *self = ST_SCROLL_VIEW_FADE (effect); st_adjustment_get_values (self->vadjustment, &value, &lower, &upper, NULL, NULL, &page_size); needs_fade = (value > lower + 0.1) || (value < upper - page_size - 0.1); if (!needs_fade) { st_adjustment_get_values (self->hadjustment, &value, &lower, &upper, NULL, NULL, &page_size); needs_fade = (value > lower + 0.1) || (value < upper - page_size - 0.1); } clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), needs_fade); }
static gboolean shell_grid_desaturate_effect_pre_paint (ClutterEffect *effect) { ShellGridDesaturateEffect *self = SHELL_GRID_DESATURATE_EFFECT (effect); ClutterEffectClass *parent_class; if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect))) return FALSE; if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL)) { /* if we don't have support for GLSL shaders then we * forcibly disable the ActorMeta */ g_warning ("Unable to use the ShaderEffect: the graphics hardware " "or the current GL driver does not implement support " "for the GLSL shading language."); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE); return FALSE; } parent_class = CLUTTER_EFFECT_CLASS (shell_grid_desaturate_effect_parent_class); if (parent_class->pre_paint (effect)) { ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect); CoglHandle texture; texture = clutter_offscreen_effect_get_texture (offscreen_effect); self->tex_width = cogl_texture_get_width (texture); self->tex_height = cogl_texture_get_height (texture); if (self->unshaded_uniform_dirty) update_unshaded_uniform (self); cogl_pipeline_set_layer_texture (self->pipeline, 0, texture); return TRUE; } else return FALSE; }
static void mex_action_button_init (MexActionButton *self) { ClutterColor shadow_color = {0, 0, 0, 64}; MexActionButtonPrivate *priv; priv = self->priv = ACTION_BUTTON_PRIVATE (self); mx_button_set_icon_position (MX_BUTTON (self), MX_POSITION_RIGHT); mx_bin_set_fill (MX_BIN (self), TRUE, TRUE); priv->shadow = mex_shadow_new (); mex_shadow_set_radius_x (priv->shadow, 15); mex_shadow_set_radius_y (priv->shadow, 15); mex_shadow_set_color (priv->shadow, &shadow_color); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (priv->shadow), FALSE); clutter_actor_add_effect (CLUTTER_ACTOR (self), CLUTTER_EFFECT (priv->shadow)); }
static gboolean shell_anamorphosis_effect_pre_paint (ClutterEffect *effect) { ShellAnamorphosisEffect *self = SHELL_ANAMORPHOSIS_EFFECT (effect); ShellAnamorphosisEffectPrivate *priv = shell_anamorphosis_effect_get_instance_private (self); if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect))) return FALSE; /* If we're not doing any bending, we're not needed. */ if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL)) { /* if we don't have support for GLSL shaders then we * forcibly disable the ActorMeta */ g_warning ("Unable to use the ShellAnamorphosisEffect: the " "graphics hardware or the current GL driver does not " "implement support for the GLSL shading language. The " "effect will be disabled."); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE); return FALSE; } if (!CLUTTER_EFFECT_CLASS (shell_anamorphosis_effect_parent_class)->pre_paint (effect)) return FALSE; ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect); CoglObject *texture; texture = clutter_offscreen_effect_get_texture (offscreen_effect); cogl_pipeline_set_layer_texture (priv->pipeline, 0, texture); priv->tex_width = cogl_texture_get_width (texture); priv->tex_height = cogl_texture_get_height (texture); cogl_pipeline_set_uniform_1i (priv->pipeline, priv->tex_width_uniform, priv->tex_width); cogl_pipeline_set_uniform_1i (priv->pipeline, priv->tex_height_uniform, priv->tex_height); return TRUE; }
/** * mex_column_add_content: * * Add an item to the column for the specified content at the specified * position. */ static void mex_column_add_content (MexColumn *column, MexContent *content, guint position) { MexColumnPrivate *priv = column->priv; ClutterActor *box; MexShadow *shadow; ClutterColor shadow_color = { 0, 0, 0, 128 }; GList *sibling; box = mex_content_box_new (); mex_content_view_set_content (MEX_CONTENT_VIEW (box), content); mex_content_view_set_context (MEX_CONTENT_VIEW (box), priv->model); sibling = g_list_nth (priv->children, position); priv->children = g_list_insert_before (priv->children, sibling, box); priv->n_items ++; /* add shadow */ shadow = mex_shadow_new (); mex_shadow_set_paint_flags (shadow, MEX_TEXTURE_FRAME_TOP | MEX_TEXTURE_FRAME_BOTTOM); mex_shadow_set_radius_y (shadow, 25); mex_shadow_set_color (shadow, &shadow_color); clutter_actor_add_effect_with_name (CLUTTER_ACTOR (box), "shadow", CLUTTER_EFFECT (shadow)); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (shadow), FALSE); g_signal_connect (box, "notify::open", G_CALLBACK (content_box_open_notify), column); /* set important if the column has focus */ mex_content_box_set_important (MEX_CONTENT_BOX (box), priv->has_focus); clutter_actor_set_parent (box, CLUTTER_ACTOR (column)); }
static void clutter_actor_meta_set_property (GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec) { ClutterActorMeta *meta = CLUTTER_ACTOR_META (gobject); switch (prop_id) { case PROP_NAME: clutter_actor_meta_set_name (meta, g_value_get_string (value)); break; case PROP_ENABLED: clutter_actor_meta_set_enabled (meta, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); break; } }
static void mx_label_init (MxLabel *label) { MxLabelPrivate *priv; const ClutterColor opaque = { 0xff, 0xff, 0xff, 0xff }; label->priv = priv = MX_LABEL_GET_PRIVATE (label); priv->label = g_object_new (CLUTTER_TYPE_TEXT, "ellipsize", PANGO_ELLIPSIZE_END, NULL); clutter_actor_set_parent (priv->label, CLUTTER_ACTOR (label)); priv->fade_effect = mx_fade_effect_new (); mx_fade_effect_set_color (MX_FADE_EFFECT (priv->fade_effect), &opaque); clutter_actor_add_effect (priv->label, priv->fade_effect); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (priv->fade_effect), FALSE); g_signal_connect (label, "style-changed", G_CALLBACK (mx_label_style_changed), NULL); g_signal_connect (priv->label, "notify::single-line-mode", G_CALLBACK (mx_label_single_line_mode_cb), label); g_signal_connect_swapped (priv->label, "queue-redraw", G_CALLBACK (mx_label_label_changed_cb), label); priv->fade_timeline = clutter_timeline_new (250); priv->fade_alpha = clutter_alpha_new_full (priv->fade_timeline, CLUTTER_EASE_OUT_QUAD); g_signal_connect (priv->fade_timeline, "new-frame", G_CALLBACK (mx_label_fade_new_frame_cb), label); g_signal_connect (priv->fade_timeline, "started", G_CALLBACK (mx_label_fade_started_cb), label); g_signal_connect (priv->fade_timeline, "completed", G_CALLBACK (mx_label_fade_completed_cb), label); }
static gboolean st_background_effect_pre_paint (ClutterEffect *effect) { StBackgroundEffect *self = ST_BACKGROUND_EFFECT (effect); ClutterEffectClass *parent_class; gfloat width; gfloat height; gfloat posx; gfloat posy; guchar *data; guint size; guint rowstride; glong new_time; gdouble time_used; ClutterActor *stage; gfloat stage_width; gfloat stage_height; if (self->bg_bumpmap == NULL) return FALSE; if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect))) return FALSE; self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect)); if (self->actor == NULL) return FALSE; if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL)) { /* if we don't have support for GLSL shaders then we * forcibly disable the ActorMeta */ g_warning ("Unable to use the ShaderEffect: the graphics hardware " "or the current GL driver does not implement support " "for the GLSL shading language."); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE); return FALSE; } new_time = clock(); time_used = ((double) (new_time - self->old_time)*100) / (double) CLOCKS_PER_SEC; self->old_time = new_time; posx = 0.0f; posy = 0.0f; width = 0.0f; height = 0.0f; stage_width = 0.0f; stage_height = 0.0f; clutter_actor_get_transformed_position (self->actor, &posx, &posy); clutter_actor_get_transformed_size (self->actor, &width, &height); self->opacity = clutter_actor_get_paint_opacity (self->actor); stage = clutter_actor_get_stage (self->actor); clutter_actor_get_size (stage, &stage_width, &stage_height); if ((posx < 0) || (posy < 0) || ((posx + width) > stage_width) || ((posy + height) > stage_height)) return FALSE; if (( posx != self->posx_old) || ( posy != self->posy_old) || ( width != self->width_old) || ( height != self->height_old) || (time_used > 50.0)) { self->posx_old = posx; self->posy_old = posy; self->width_old = width; self->height_old = height; self->bg_posx_i = round(posx)+2; self->bg_posy_i = round(posy)+2; self->bg_width_i = round(width)-4; self->bg_height_i = round(height)-4; size = (self->bg_width_i) * (self->bg_height_i) * 4; if (((self->opacity == 0xff) || (self->bg_texture == NULL)) && (size > 400)) { rowstride = (self->bg_width_i) * 4; data = g_malloc (size); cogl_read_pixels (self->bg_posx_i, self->bg_posy_i, self->bg_width_i, self->bg_height_i, COGL_READ_PIXELS_COLOR_BUFFER, COGL_PIXEL_FORMAT_RGBA_8888_PRE, data); if (data != NULL) { if (self->bg_texture != NULL) { cogl_handle_unref (self->bg_texture); self->bg_texture = NULL; } self->bg_texture = st_cogl_texture_new_from_data_wrapper (self->bg_width_i, self->bg_height_i, COGL_TEXTURE_NO_SLICING, COGL_PIXEL_FORMAT_RGBA_8888_PRE, COGL_PIXEL_FORMAT_RGBA_8888_PRE, rowstride, data); g_free (data); } } } parent_class = CLUTTER_EFFECT_CLASS (st_background_effect_parent_class); if (parent_class->pre_paint (effect)) { ClutterOffscreenEffect *offscreen_effect = CLUTTER_OFFSCREEN_EFFECT (effect); CoglHandle fg_texture; fg_texture = clutter_offscreen_effect_get_texture (offscreen_effect); if (fg_texture != COGL_INVALID_HANDLE) { self->fg_width_i = cogl_texture_get_width (fg_texture); self->fg_height_i = cogl_texture_get_height (fg_texture); if ((self->bg_texture != NULL) && (self->opacity == 0xff)) { if (self->pixel_step_uniform0 > -1) { gfloat pixel_step[3]; pixel_step[0] = 1.0f / (self->bg_width_i); pixel_step[1] = 1.0f / (self->bg_height_i); pixel_step[2] = 0.0f; cogl_pipeline_set_uniform_float (self->pipeline0, self->pixel_step_uniform0, 3, 1, pixel_step); } if (self->BumpTex_uniform > -1) { cogl_pipeline_set_uniform_1i (self->pipeline0, self->BumpTex_uniform, 1); } if (self->bump_step_uniform > -1) { gfloat bump_step[2]; bump_step[0] = 1.0f / (self->bumptex_width_i); bump_step[1] = 1.0f / (self->bumptex_height_i); cogl_pipeline_set_uniform_float (self->pipeline0, self->bump_step_uniform, 2, 1, bump_step); } if (self->bg_sub_texture != NULL) { cogl_handle_unref (self->bg_sub_texture); self->bg_sub_texture = NULL; } self->bg_sub_texture = st_cogl_texture_new_with_size_wrapper (self->bg_width_i, self->bg_height_i, COGL_TEXTURE_NO_SLICING, COGL_PIXEL_FORMAT_RGBA_8888_PRE); cogl_pipeline_set_layer_texture (self->pipeline0, 0, self->bg_texture); if (self->pixel_step_uniform1 > -1) { gfloat pixel_step[3]; pixel_step[0] = 1.0f / (self->bg_width_i); pixel_step[1] = 1.0f / (self->bg_height_i); pixel_step[2] = 1.0f; cogl_pipeline_set_uniform_float (self->pipeline1, self->pixel_step_uniform1, 3, 1, pixel_step); } if (self->pixel_step_uniform2 > -1) { gfloat pixel_step[3]; pixel_step[0] = 1.0f / (self->fg_width_i); pixel_step[1] = 1.0f / (self->fg_height_i); pixel_step[2] = 2.0f; cogl_pipeline_set_uniform_float (self->pipeline3, self->pixel_step_uniform2, 3, 1, pixel_step); } } cogl_pipeline_set_layer_texture (self->pipeline2, 0, fg_texture); cogl_pipeline_set_layer_texture (self->pipeline3, 0, fg_texture); cogl_pipeline_set_layer_texture (self->pipeline4, 0, fg_texture); } return TRUE; } else { return FALSE; } }
static gboolean cd_icc_effect_pre_paint (ClutterEffect *effect) { CdIccEffect *self = CD_ICC_EFFECT (effect); ClutterEffectClass *parent_class; ClutterActorBox allocation; gfloat width, height; if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect))) return FALSE; self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect)); if (self->actor == NULL) return FALSE; if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL)) { /* if we don't have support for GLSL shaders then we * forcibly disable the ActorMeta */ g_warning ("Unable to use the ShaderEffect: the graphics hardware " "or the current GL driver does not implement support " "for the GLSL shading language."); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE); return FALSE; } clutter_actor_get_allocation_box (self->actor, &allocation); clutter_actor_box_get_size (&allocation, &width, &height); if (self->shader == COGL_INVALID_HANDLE) { self->shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT); cogl_shader_source (self->shader, glsl_shader); self->is_compiled = FALSE; self->main_texture_uniform = -1; self->indirect_texture_uniform = -1; self->color_data1_uniform = -1; self->color_data2_uniform = -1; } if (self->program == COGL_INVALID_HANDLE) self->program = cogl_create_program (); if (!self->is_compiled) { g_assert (self->shader != COGL_INVALID_HANDLE); g_assert (self->program != COGL_INVALID_HANDLE); cogl_shader_compile (self->shader); if (!cogl_shader_is_compiled (self->shader)) { gchar *log_buf = cogl_shader_get_info_log (self->shader); g_warning (G_STRLOC ": Unable to compile the icc shader: %s", log_buf); g_free (log_buf); cogl_handle_unref (self->shader); cogl_handle_unref (self->program); self->shader = COGL_INVALID_HANDLE; self->program = COGL_INVALID_HANDLE; } else { cogl_program_attach_shader (self->program, self->shader); cogl_program_link (self->program); cogl_handle_unref (self->shader); self->is_compiled = TRUE; self->main_texture_uniform = cogl_program_get_uniform_location (self->program, "main_texture"); self->indirect_texture_uniform = cogl_program_get_uniform_location (self->program, "indirect_texture"); self->color_data1_uniform = cogl_program_get_uniform_location (self->program, "color_data1"); self->color_data2_uniform = cogl_program_get_uniform_location (self->program, "color_data2"); } } parent_class = CLUTTER_EFFECT_CLASS (cd_icc_effect_parent_class); return parent_class->pre_paint (effect); }
static void mex_tile_allocate (ClutterActor *actor, const ClutterActorBox *box, ClutterAllocationFlags flags) { MxPadding padding; ClutterActorBox child_box; gfloat available_width, available_height; ClutterEffect *fade; MexTilePrivate *priv = MEX_TILE (actor)->priv; CLUTTER_ACTOR_CLASS (mex_tile_parent_class)->allocate (actor, box, flags); mx_widget_get_padding (MX_WIDGET (actor), &padding); available_width = box->x2 - box->x1 - padding.left - padding.right; available_height = box->y2 - box->y1 - padding.top - padding.bottom; if (priv->child) { gfloat child_width, full_width, full_height; clutter_actor_get_preferred_size (priv->child, NULL, NULL, &full_width, &full_height); child_box.y1 = padding.top; if (clutter_alpha_get_alpha (priv->important_alpha) < 0.5) { child_width = full_width * (available_height / full_height); if (child_width > available_width) child_width = available_width; child_box.y2 = child_box.y1 + available_height; /* When we're in unimportant state, make sure the label * doesn't overlap the image. */ if (available_height < full_height) available_width -= child_width * ((0.5 - clutter_alpha_get_alpha (priv->important_alpha)) * 2); } else { child_width = available_width; clutter_actor_set_clip_to_allocation ( actor, (full_height > available_height)); child_box.y2 = child_box.y1 + full_height; } child_box.x2 = box->x2 - box->x1 - padding.right; child_box.x1 = child_box.x2 - child_width; mx_allocate_align_fill (priv->child, &child_box, MX_ALIGN_MIDDLE, MX_ALIGN_MIDDLE, FALSE, FALSE); clutter_actor_allocate (priv->child, &child_box, flags); } /* Allocate Header */ if (priv->header_visible) { gfloat icon1_w, icon1_h, icon2_w, icon2_h, label_h, label_w, header_h; gfloat middle_w; if (priv->header_padding) { padding.top += priv->header_padding->top; padding.right += priv->header_padding->right; padding.bottom += priv->header_padding->bottom; padding.left += priv->header_padding->left; } clutter_actor_get_preferred_size (priv->box_layout, NULL, NULL, &label_w, &label_h); if (priv->icon1) clutter_actor_get_preferred_size (priv->icon1, NULL, NULL, &icon1_w, &icon1_h); else icon1_h = icon1_w = 0; if (priv->icon2) clutter_actor_get_preferred_size (priv->icon2, NULL, NULL, &icon2_w, &icon2_h); else icon2_h = icon2_w = 0; header_h = MAX (icon1_h, MAX (icon2_h, label_h)); /* primary icon */ if (priv->icon1) { child_box.y1 = padding.top + (header_h / 2.0) - (icon1_h / 2.0); child_box.x1 = padding.left; child_box.y2 = child_box.y1 + icon1_h; child_box.x2 = child_box.x1 + icon1_w; clutter_actor_allocate (priv->icon1, &child_box, flags); child_box.x1 += icon1_w + 8; } else child_box.x1 = padding.left; /* label */ child_box.x2 = child_box.x1 + label_w; child_box.y1 = (int) (padding.top + (header_h / 2.0) - (label_h / 2.0)); child_box.y2 = child_box.y1 + label_h; fade = clutter_actor_get_effect (priv->box_layout, "fade"); middle_w = available_width - icon1_w - icon2_w; if (priv->header_padding) middle_w -= priv->header_padding->left + priv->header_padding->right; clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (fade), !(middle_w > label_w)); mx_fade_effect_set_bounds (MX_FADE_EFFECT (fade), 0, 0, middle_w, 0); clutter_actor_allocate (priv->box_layout, &child_box, flags); /* secondary icon */ if (priv->icon2) { child_box.x2 = (box->x2 - box->x1) - padding.right; child_box.x1 = child_box.x2 - icon2_w; child_box.y1 = padding.top + (header_h / 2.0) - (icon2_h / 2.0); child_box.y2 = child_box.y1 + icon2_h; clutter_actor_allocate (priv->icon2, &child_box, flags); } priv->header_height = header_h; if (priv->header_padding) priv->header_height += priv->header_padding->top + priv->header_padding->bottom; } }
static gboolean clutter_colorize_effect_pre_paint (ClutterEffect *effect) { ClutterColorizeEffect *self = CLUTTER_COLORIZE_EFFECT (effect); ClutterEffectClass *parent_class; if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (effect))) return FALSE; self->actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (effect)); if (self->actor == NULL) return FALSE; if (!clutter_feature_available (CLUTTER_FEATURE_SHADERS_GLSL)) { /* if we don't have support for GLSL shaders then we * forcibly disable the ActorMeta */ g_warning ("Unable to use the ShaderEffect: the graphics hardware " "or the current GL driver does not implement support " "for the GLSL shading language."); clutter_actor_meta_set_enabled (CLUTTER_ACTOR_META (effect), FALSE); return FALSE; } if (self->shader == COGL_INVALID_HANDLE) { self->shader = cogl_create_shader (COGL_SHADER_TYPE_FRAGMENT); cogl_shader_source (self->shader, colorize_glsl_shader); self->is_compiled = FALSE; self->tex_uniform = -1; self->tint_uniform = -1; } if (self->program == COGL_INVALID_HANDLE) self->program = cogl_create_program (); if (!self->is_compiled) { g_assert (self->shader != COGL_INVALID_HANDLE); g_assert (self->program != COGL_INVALID_HANDLE); cogl_shader_compile (self->shader); if (!cogl_shader_is_compiled (self->shader)) { gchar *log_buf = cogl_shader_get_info_log (self->shader); g_warning (G_STRLOC ": Unable to compile the colorize shader: %s", log_buf); g_free (log_buf); cogl_handle_unref (self->shader); cogl_handle_unref (self->program); self->shader = COGL_INVALID_HANDLE; self->program = COGL_INVALID_HANDLE; } else { cogl_program_attach_shader (self->program, self->shader); cogl_program_link (self->program); cogl_handle_unref (self->shader); self->is_compiled = TRUE; self->tex_uniform = cogl_program_get_uniform_location (self->program, "tex"); self->tint_uniform = cogl_program_get_uniform_location (self->program, "tint"); } } parent_class = CLUTTER_EFFECT_CLASS (clutter_colorize_effect_parent_class); return parent_class->pre_paint (effect); }