/*< private >
* _clutter_paint_node_init_types:
*
* Initializes the required types for ClutterPaintNode subclasses
*/
void
_clutter_paint_node_init_types (void)
{
CoglContext *ctx;
CoglColor cogl_color;
GType node_type G_GNUC_UNUSED;
if (G_LIKELY (default_color_pipeline != NULL))
return;
ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
node_type = clutter_paint_node_get_type ();
cogl_color_init_from_4f (&cogl_color, 1.0, 1.0, 1.0, 1.0);
default_color_pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_color (default_color_pipeline, &cogl_color);
default_texture_pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_null_texture (default_texture_pipeline, 0,
COGL_TEXTURE_TYPE_2D);
cogl_pipeline_set_color (default_texture_pipeline, &cogl_color);
cogl_pipeline_set_layer_wrap_mode (default_texture_pipeline, 0,
COGL_PIPELINE_WRAP_MODE_AUTOMATIC);
}
/* XXX: deprecated, use cogl_color_init_from_4f */
void
cogl_color_set_from_4f (CoglColor *color,
float red,
float green,
float blue,
float alpha)
{
cogl_color_init_from_4f (color, red, green, blue, alpha);
}
void
cogl_set_source_color4f (float red,
float green,
float blue,
float alpha)
{
CoglColor c = { 0, };
cogl_color_init_from_4f (&c, red, green, blue, alpha);
cogl_set_source_color (&c);
}
void
cogl_pipeline_set_color4f (CoglPipeline *pipeline,
float red,
float green,
float blue,
float alpha)
{
CoglColor color;
cogl_color_init_from_4f (&color, red, green, blue, alpha);
cogl_pipeline_set_color (pipeline, &color);
}
void
cogl_color_init_from_hsl (CoglColor *color,
float hue,
float saturation,
float luminance)
{
float tmp1, tmp2;
float tmp3[3];
float clr[3];
int i;
hue /= 360.0;
if (saturation == 0)
{
cogl_color_init_from_4f (color, luminance, luminance, luminance, 1.0f);
return;
}
if (luminance <= 0.5)
tmp2 = luminance * (1.0 + saturation);
else
tmp2 = luminance + saturation - (luminance * saturation);
tmp1 = 2.0 * luminance - tmp2;
tmp3[0] = hue + 1.0 / 3.0;
tmp3[1] = hue;
tmp3[2] = hue - 1.0 / 3.0;
for (i = 0; i < 3; i++)
{
if (tmp3[i] < 0)
tmp3[i] += 1.0;
if (tmp3[i] > 1)
tmp3[i] -= 1.0;
if (6.0 * tmp3[i] < 1.0)
clr[i] = tmp1 + (tmp2 - tmp1) * tmp3[i] * 6.0;
else if (2.0 * tmp3[i] < 1.0)
clr[i] = tmp2;
else if (3.0 * tmp3[i] < 2.0)
clr[i] = (tmp1 + (tmp2 - tmp1) * ((2.0 / 3.0) - tmp3[i]) * 6.0);
else
clr[i] = tmp1;
}
color->red = clr[0];
color->green = clr[1];
color->blue = clr[2];
color->alpha = 1.0f;
}
void
rut_camera_set_background_color4f (RutCamera *camera,
float red,
float green,
float blue,
float alpha)
{
cogl_color_init_from_4f (&camera->bg_color,
red, green, blue, alpha);
rut_property_dirty (&camera->ctx->property_ctx,
&camera->properties[RUT_CAMERA_PROP_BG_COLOR]);
}
RutLight *
rut_light_new (RutContext *context)
{
RutLight *light;
light = g_slice_new0 (RutLight);
rut_object_init (&light->_parent, &rut_light_type);
light->ref_count = 1;
light->component.type = RUT_COMPONENT_TYPE_LIGHT;
light->context = rut_refable_ref (context);
rut_simple_introspectable_init (light,
_rut_light_prop_specs,
light->properties);
cogl_color_init_from_4f (&light->ambient, 1.0, 1.0, 1.0, 1.0);
cogl_color_init_from_4f (&light->diffuse, 1.0, 1.0, 1.0, 1.0);
cogl_color_init_from_4f (&light->specular, 1.0, 1.0, 1.0, 1.0);
return light;
}
RutButton *
rut_button_new (RutContext *ctx,
const char *label)
{
RutButton *button = g_slice_new0 (RutButton);
GError *error = NULL;
float text_width, text_height;
static CoglBool initialized = FALSE;
if (initialized == FALSE)
{
_rut_button_init_type ();
initialized = TRUE;
}
rut_object_init (RUT_OBJECT (button), &rut_button_type);
button->ref_count = 1;
rut_list_init (&button->on_click_cb_list);
rut_graphable_init (RUT_OBJECT (button));
rut_paintable_init (RUT_OBJECT (button));
button->ctx = ctx;
button->state = BUTTON_STATE_NORMAL;
button->normal_texture =
rut_load_texture_from_data_file (ctx, "button.png", &error);
if (button->normal_texture)
{
button->background_normal =
rut_nine_slice_new (ctx, button->normal_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button texture: %s", error->message);
g_error_free (error);
}
button->hover_texture =
rut_load_texture_from_data_file (ctx, "button-hover.png", &error);
if (button->hover_texture)
{
button->background_hover =
rut_nine_slice_new (ctx, button->hover_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button-hover texture: %s", error->message);
g_error_free (error);
}
button->active_texture =
rut_load_texture_from_data_file (ctx, "button-active.png", &error);
if (button->active_texture)
{
button->background_active =
rut_nine_slice_new (ctx, button->active_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button-active texture: %s", error->message);
g_error_free (error);
}
button->disabled_texture =
rut_load_texture_from_data_file (ctx, "button-disabled.png", &error);
if (button->disabled_texture)
{
button->background_disabled =
rut_nine_slice_new (ctx, button->disabled_texture, 11, 5, 13, 5,
button->width,
button->height);
}
else
{
g_warning ("Failed to load button-disabled texture: %s", error->message);
g_error_free (error);
}
button->text = rut_text_new_with_text (ctx, NULL, label);
button->text_transform = rut_transform_new (ctx);
rut_graphable_add_child (button, button->text_transform);
rut_graphable_add_child (button->text_transform, button->text);
rut_sizable_get_size (button->text, &text_width, &text_height);
button->width = text_width + BUTTON_HPAD;
button->height = text_height + BUTTON_VPAD;
cogl_color_init_from_4f (&button->text_color, 0, 0, 0, 1);
button->input_region =
rut_input_region_new_rectangle (0, 0, button->width, button->height,
_rut_button_input_cb,
button);
//rut_input_region_set_graphable (button->input_region, button);
rut_graphable_add_child (button, button->input_region);
queue_allocation (button);
return button;
}
RutFold *
rut_fold_new (RutContext *ctx,
const char *label)
{
RutFold *fold = g_slice_new0 (RutFold);
static CoglBool initialized = FALSE;
RutBoxLayout *header_hbox;
RutStack *left_header_stack;
RutBoxLayout *left_header_hbox;
RutBin *label_bin;
RutBin *fold_icon_align;
CoglTexture *texture;
CoglColor black;
if (initialized == FALSE)
{
_rut_fold_init_type ();
initialized = TRUE;
}
fold->ref_count = 1;
fold->context = ctx;
rut_object_init (&fold->_parent, &rut_fold_type);
rut_graphable_init (fold);
rut_simple_introspectable_init (fold,
_rut_fold_prop_specs,
fold->properties);
fold->vbox = rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_TOP_TO_BOTTOM);
header_hbox =
rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_LEFT_TO_RIGHT);
rut_box_layout_add (fold->vbox, FALSE, header_hbox);
rut_refable_unref (header_hbox);
left_header_stack = rut_stack_new (ctx, 0, 0);
rut_box_layout_add (header_hbox, TRUE, left_header_stack);
rut_refable_unref (left_header_stack);
left_header_hbox =
rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_LEFT_TO_RIGHT);
rut_stack_add (left_header_stack, left_header_hbox);
rut_refable_unref (left_header_hbox);
fold_icon_align = rut_bin_new (ctx);
rut_bin_set_x_position (fold_icon_align, RUT_BIN_POSITION_BEGIN);
rut_bin_set_y_position (fold_icon_align, RUT_BIN_POSITION_CENTER);
rut_bin_set_right_padding (fold_icon_align, 10);
rut_box_layout_add (left_header_hbox, FALSE, fold_icon_align);
rut_refable_unref (fold_icon_align);
texture = rut_load_texture_from_data_file (ctx, "tri-fold-up.png", NULL);
fold->fold_up_icon = rut_nine_slice_new (ctx, texture,
0, 0, 0, 0,
cogl_texture_get_width (texture),
cogl_texture_get_height (texture));
cogl_object_unref (texture);
texture = rut_load_texture_from_data_file (ctx, "tri-fold-down.png", NULL);
fold->fold_down_icon = rut_nine_slice_new (ctx, texture,
0, 0, 0, 0,
cogl_texture_get_width (texture),
cogl_texture_get_height (texture));
cogl_object_unref (texture);
fold->fold_icon_shim = rut_fixed_new (ctx,
cogl_texture_get_width (texture),
cogl_texture_get_height (texture));
rut_bin_set_child (fold_icon_align, fold->fold_icon_shim);
rut_refable_unref (fold->fold_icon_shim);
rut_graphable_add_child (fold->fold_icon_shim, fold->fold_down_icon);
/* NB: we keep references to the icons so they can be swapped
* without getting disposed. */
label_bin = rut_bin_new (ctx);
rut_bin_set_y_position (label_bin, RUT_BIN_POSITION_CENTER);
rut_box_layout_add (left_header_hbox, FALSE, label_bin);
rut_refable_unref (label_bin);
fold->label = rut_text_new_with_text (ctx, NULL, label);
rut_bin_set_child (label_bin, fold->label);
rut_refable_unref (fold->label);
fold->header_hbox_right =
rut_box_layout_new (ctx, RUT_BOX_LAYOUT_PACKING_RIGHT_TO_LEFT);
rut_box_layout_add (header_hbox, TRUE, fold->header_hbox_right);
rut_refable_unref (fold->header_hbox_right);
cogl_color_init_from_4f (&black, 0, 0, 0, 1);
rut_fold_set_folder_color (fold, &black);
rut_fold_set_label_color (fold, &black);
rut_graphable_add_child (fold, fold->vbox);
rut_refable_unref (fold->vbox);
fold->input_region = rut_input_region_new_rectangle (0, 0, 0, 0,
input_cb,
fold);
rut_stack_add (left_header_stack, fold->input_region);
rut_refable_unref (fold->input_region);
fold->folded = FALSE;
return fold;
}
static void _clone_paint_cb (ClutterActor *actor) {
ClutterActor *source;
ClutterActorBox box;
CoglHandle material;
gfloat width, height;
guint8 opacity;
CoglColor color_1, color_2;
CoglTextureVertex vertices[4];
/* if we don't have a source actor, don't paint */
source = clutter_clone_get_source (CLUTTER_CLONE (actor));
if (source == NULL)
goto out;
/* if the source texture does not have any content, don't paint */
material = clutter_texture_get_cogl_material (CLUTTER_TEXTURE (source));
if (material == NULL)
goto out;
/* get the size of the reflection */
clutter_actor_get_allocation_box (actor, &box);
clutter_actor_box_get_size (&box, &width, &height);
/* get the composite opacity of the actor */
opacity = clutter_actor_get_paint_opacity (actor);
/* figure out the two colors for the reflection: the first is
* full color and the second is the same, but at 0 opacity
*/
cogl_color_init_from_4f (&color_1, 1.0, 1.0, 1.0, opacity / 255.0);
cogl_color_premultiply (&color_1);
cogl_color_init_from_4f (&color_2, 1.0, 1.0, 1.0, 0.0);
cogl_color_premultiply (&color_2);
/* now describe the four vertices of the quad; since it has
* to be a reflection, we need to invert it as well
*/
vertices[0].x = 0; vertices[0].y = 0; vertices[0].z = 0;
vertices[0].tx = 0.0; vertices[0].ty = 1.0;
vertices[0].color = color_1;
vertices[1].x = width; vertices[1].y = 0; vertices[1].z = 0;
vertices[1].tx = 1.0; vertices[1].ty = 1.0;
vertices[1].color = color_1;
vertices[2].x = width; vertices[2].y = height; vertices[2].z = 0;
vertices[2].tx = 1.0; vertices[2].ty = 0.0;
vertices[2].color = color_2;
vertices[3].x = 0; vertices[3].y = height; vertices[3].z = 0;
vertices[3].tx = 0.0; vertices[3].ty = 0.0;
vertices[3].color = color_2;
/* paint the same texture but with a different geometry */
cogl_set_source (material);
cogl_polygon (vertices, 4, TRUE);
out:
/* prevent the default clone handler from running */
g_signal_stop_emission_by_name (actor, "paint");
}
