static void clutter_widget_paint ( ClutterActor *_self ) {
ClutterGeometry geom;
ClutterWidgetPrivate *priv;
int borderWidth = 1;
priv = CLUTTER_WIDGET_GET_PRIVATE (_self);
clutter_actor_get_geometry (_self, &geom);
cogl_push_matrix ();
cogl_path_round_rectangle ( -borderWidth, -borderWidth,
geom.width + borderWidth, geom.height + borderWidth,
5, 1 );
cogl_set_source_color4ub ( priv->borderColor.red,
priv->borderColor.green,
priv->borderColor.blue,
priv->borderColor.alpha );
cogl_path_fill ();
cogl_path_round_rectangle ( 0, 0, geom.width, geom.height, 5, 1 );
cogl_set_source_color4ub ( 0xcf, 0xcf, 0xcf, 0xff );
cogl_path_fill ();
cogl_pop_matrix();
// call the parent paint
CLUTTER_ACTOR_CLASS (clutter_widget_parent_class)->paint (_self);
}
static void
draw_shapes (gint x, gint y)
{
path_shapes (x, y, 300, 100);
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_path_fill_preserve ();
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_path_stroke ();
}
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_polygon_pick (ClutterActor *self,
const ClutterColor *pick_color)
{
CoglPath *selection_path;
gfloat coords[8];
StPolygon *area = ST_POLYGON (self);
StPolygonPrivate *priv = area->priv;
if (!clutter_actor_should_pick_paint (self))
return;
coords[0] = priv->ulc_x;
coords[1] = priv->ulc_y;
coords[2] = priv->llc_x;
coords[3] = priv->llc_y;
coords[4] = priv->lrc_x;
coords[5] = priv->lrc_y;
coords[6] = priv->urc_x;
coords[7] = priv->urc_y;
cogl_set_source_color4ub (pick_color->red,
pick_color->green,
pick_color->blue,
pick_color->alpha);
selection_path = cogl_path_new();
cogl_path_polygon (selection_path, (float *)coords, 4);
cogl_path_fill (selection_path);
cogl_object_unref (selection_path);
}
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
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);
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
/* Draw a faded blue triangle */
cogl_vertex_buffer_enable (state->buffer, "gl_Color::blue");
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* Draw a red triangle */
/* Here we are testing that the disable attribute works; if it doesn't
* the triangle will remain faded blue */
cogl_translate (100, 0, 0);
cogl_vertex_buffer_disable (state->buffer, "gl_Color::blue");
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* Draw a faded blue triangle */
/* Here we are testing that the re-enable works; if it doesn't
* the triangle will remain red */
cogl_translate (100, 0, 0);
cogl_vertex_buffer_enable (state->buffer, "gl_Color::blue");
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
/* Draw a textured triangle */
cogl_translate (100, 0, 0);
cogl_vertex_buffer_disable (state->buffer, "gl_Color::blue");
cogl_set_source (state->material);
cogl_material_set_color4ub (state->material, 0xff, 0xff, 0xff, 0xff);
cogl_vertex_buffer_draw (state->buffer,
GL_TRIANGLE_STRIP, /* mode */
0, /* first */
3); /* count */
validate_result (state);
}
static void
paint_circle (ClutterActor *actor)
{
gfloat radius = MIN (clutter_actor_get_width (actor),
clutter_actor_get_height (actor)) / 2.f;
cogl_set_source_color4ub (0xff, 0xff, 0xff, 0xff);
cogl_path_arc (radius, radius, radius, radius, 0, 360);
cogl_path_fill ();
}
void cs_selected_paint (void)
{
ClutterVertex verts[4];
/* draw outlines for actors */
GHashTableIter iter;
gpointer key, value;
{
{
if (cs->fake_stage)
{
cogl_set_source_color4ub (0, 255, 0, 255);
cs_draw_actor_outline (cs->fake_stage, NULL);
}
}
}
cogl_set_source_color4ub (255, 0, 0, 128);
cs_selected_foreach (G_CALLBACK (cs_draw_actor_outline), NULL);
g_hash_table_iter_init (&iter, selection);
while (g_hash_table_iter_next (&iter, &key, &value))
{
clutter_actor_get_abs_allocation_vertices (key,
verts);
cogl_set_source_color4ub (0, 0, 25, 50);
{
{
gfloat coords[]={ verts[0].x, verts[0].y,
verts[1].x, verts[1].y,
verts[3].x, verts[3].y,
verts[2].x, verts[2].y,
verts[0].x, verts[0].y };
cogl_path_polyline (coords, 5);
cogl_set_source_color4ub (0, 0, 255, 128);
cogl_path_stroke ();
}
}
}
}
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
paint_cb (ClutterActor *self, ClutterTimeline *tl)
{
gint paint_index = (clutter_timeline_get_progress (tl)
* G_N_ELEMENTS (paint_func));
cogl_push_matrix ();
paint_func[paint_index] ();
cogl_translate (100, 100, 0);
cogl_set_source_color4ub (0, 160, 0, 255);
cogl_path_stroke_preserve ();
cogl_translate (150, 0, 0);
cogl_set_source_color4ub (200, 0, 0, 255);
cogl_path_fill ();
cogl_pop_matrix();
}
static void
on_paint (ClutterActor *actor, TestState *state)
{
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_vertex_buffer_draw_elements (state->buffer,
COGL_VERTICES_MODE_TRIANGLE_STRIP,
state->indices,
0, /* min index */
(MESH_WIDTH + 1) *
(MESH_HEIGHT + 1) - 1, /* max index */
0, /* indices offset */
state->n_static_indices);
}
static void
paint_triangle (ClutterActor *actor)
{
gfloat width, height;
clutter_actor_get_size (actor, &width, &height);
cogl_set_source_color4ub (0xff, 0xff, 0xff, 0xff);
cogl_path_move_to (width/2, 0);
cogl_path_line_to (width, height);
cogl_path_line_to (0, height);
cogl_path_close ();
cogl_path_fill ();
}
void
_example_draw_at (int x, int y)
{
cogl_set_source_color4ub ('\xFF', '1', '1', 255);
cogl_ortho (0, 64, 0, 64, -5, 5);
CoglMatrix idmtx;
cogl_matrix_init_identity (&idmtx);
cogl_set_modelview_matrix (&idmtx);
cogl_rectangle (x+1, y+1, x-1, y-1);
cogl_flush ();
}
static void
paint (TestState *state)
{
CoglColor bg;
int i;
cogl_set_source_color4ub (255, 255, 255, 255);
/* We push the third framebuffer first so that later we can switch
back to it by popping to test that that works */
cogl_push_framebuffer (state->fbo[2]);
cogl_push_framebuffer (state->fbo[0]);
cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
cogl_pop_framebuffer ();
cogl_push_framebuffer (state->fbo[1]);
cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
cogl_pop_framebuffer ();
/* We should now be back on the third framebuffer */
cogl_rectangle (-1.0, -1.0, 1.0, 1.0);
cogl_pop_framebuffer ();
cogl_color_init_from_4ub (&bg, 128, 128, 128, 255);
cogl_clear (&bg, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_DEPTH);
/* Render all of the textures to the screen */
for (i = 0; i < NUM_FBOS; i++)
{
cogl_set_source_texture (state->tex[i]);
cogl_rectangle (2.0f / NUM_FBOS * i - 1.0f, -1.0f,
2.0f / NUM_FBOS * (i + 1) - 1.0f, 1.0f);
}
/* Verify all of the fbos drew the right color */
for (i = 0; i < NUM_FBOS; i++)
{
guint8 expected_colors[NUM_FBOS][4] =
{ { 0xff, 0x00, 0x00, 0xff },
{ 0x00, 0xff, 0x00, 0xff },
{ 0x00, 0x00, 0xff, 0xff } };
test_utils_check_pixel_rgb (state->width * (i + 0.5f) / NUM_FBOS,
state->height / 2,
expected_colors[i][0],
expected_colors[i][1],
expected_colors[i][2]);
}
}
static void
mnb_launcher_button_pick (ClutterActor *actor,
const ClutterColor *color)
{
MnbLauncherButtonPrivate *priv = MNB_LAUNCHER_BUTTON (actor)->priv;
ClutterGeometry geom;
/* draw a rectangle to conver the entire actor */
clutter_actor_get_allocation_geometry (actor, &geom);
cogl_set_source_color4ub (color->red, color->green, color->blue, color->alpha);
cogl_rectangle (0, 0, geom.width, geom.height);
if (priv->fav_toggle)
clutter_actor_paint (priv->fav_toggle);
}
/*
* MxWidget::paint_background vfunction implementation.
*/
static void
mpl_panel_background_paint_background (MxWidget *self,
ClutterActor *background,
const ClutterColor *color)
{
MxPadding padding = { 0, };
mx_widget_get_padding (self, &padding);
/*
* Paint any solid background colour that is not completely transparent.
*/
if (color && color->alpha != 0)
{
ClutterActor *actor = CLUTTER_ACTOR (self);
ClutterActorBox allocation = { 0, };
ClutterColor bg_color = *color;
gfloat w, h;
bg_color.alpha = clutter_actor_get_paint_opacity (actor)
* bg_color.alpha
/ 255;
clutter_actor_get_allocation_box (actor, &allocation);
w = allocation.x2 - allocation.x1;
h = allocation.y2 - allocation.y1;
cogl_set_source_color4ub (bg_color.red,
bg_color.green,
bg_color.blue,
bg_color.alpha);
cogl_rectangle (padding.left, padding.top,
w - padding.left - padding.right,
h - padding.top - padding.bottom);
}
/*
* Now paint the asset.
*/
if (background)
mpl_panel_background_paint_border_image (MX_TEXTURE_FRAME (background),
&padding);
}
void
mai_node_draw_recursive (MaiNode *self)
{
CoglMatrix initial_mtx;
cogl_matrix_init_identity (&initial_mtx);
cogl_set_modelview_matrix (&initial_mtx);
cogl_set_source_color4ub ('\x1', '\x1', '\xFF', 255);
cogl_set_source_texture (g_testtex);
cogl_ortho (0, 64, 0, 64, -1, 1);
cogl_matrix_translate (&initial_mtx, 20.0f, 20.0f, 0.0f);
cogl_matrix_scale (&initial_mtx, 5.0f, 5.0f, 1.0f);
cogl_matrix_rotate(&initial_mtx, -90.0f, 1.0f, 0.0f, 0.0f);
_mai_node_draw_recursive (self, &initial_mtx);
cogl_flush ();
}
static void
pick (ClutterActor *self,
const ClutterColor *color)
{
ChamplainPointPrivate *priv = GET_PRIVATE (self);
gdouble radius = priv->size / 2.0;
cogl_path_new ();
cogl_set_source_color4ub (color->red,
color->green,
color->blue,
color->alpha);
cogl_path_move_to (radius, radius);
cogl_path_arc (radius, radius, radius, radius, 0, 360.0);
cogl_path_close ();
cogl_path_fill ();
}
static void
hand_post_paint (ClutterActor *actor,
gpointer user_data)
{
SuperOH *oh = user_data;
gfloat w, h;
int actor_num;
for (actor_num = 0; oh->hand[actor_num] != actor; actor_num++)
;
g_assert (oh->paint_guards[actor_num] == TRUE);
clutter_actor_get_size (actor, &w, &h);
cogl_set_source_color4ub (0, 255, 0, 128);
cogl_rectangle (w / 2, h / 2, w, h);
oh->paint_guards[actor_num] = FALSE;
}
static void
mx_scroll_view_paint (ClutterActor *actor)
{
ClutterActorBox box;
gfloat w, h;
MxAdjustment *vadjustment = NULL, *hadjustment = NULL;
MxScrollViewPrivate *priv = MX_SCROLL_VIEW (actor)->priv;
ClutterColor *color;
guint8 r, g, b;
const gint shadow = 15;
mx_stylable_get (MX_STYLABLE (actor), "background-color", &color, NULL);
r = color->red;
g = color->green;
b = color->blue;
clutter_color_free (color);
/* MxBin will paint the child */
CLUTTER_ACTOR_CLASS (mx_scroll_view_parent_class)->paint (actor);
clutter_actor_get_allocation_box (actor, &box);
w = box.x2 - box.x1;
h = box.y2 - box.y1;
/* paint our custom children */
if (CLUTTER_ACTOR_IS_VISIBLE (priv->hscroll))
{
clutter_actor_paint (priv->hscroll);
clutter_actor_get_allocation_box (priv->hscroll, &box);
h -= (box.y2 - box.y1);
hadjustment = mx_scroll_bar_get_adjustment (MX_SCROLL_BAR(priv->hscroll));
}
if (CLUTTER_ACTOR_IS_VISIBLE (priv->vscroll))
{
clutter_actor_paint (priv->vscroll);
clutter_actor_get_allocation_box (priv->vscroll, &box);
w -= (box.x2 - box.x1);
vadjustment = mx_scroll_bar_get_adjustment (MX_SCROLL_BAR(priv->vscroll));
}
/* set up the matrial using dummy set source call */
cogl_set_source_color4ub (0, 0, 0, 0);
if (vadjustment)
{
gdouble len;
if ((len = mx_adjustment_get_value (vadjustment)) > 0)
{
CoglTextureVertex top[4] = { { 0,}, };
if (len > shadow)
len = shadow;
top[1].x = w;
top[2].x = w;
top[2].y = len;
top[3].y = len;
cogl_color_set_from_4ub (&top[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&top[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&top[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&top[3].color, 0, 0, 0, 0);
cogl_polygon (top, 4, TRUE);
}
if ((len = (mx_adjustment_get_upper (vadjustment)
- mx_adjustment_get_page_size (vadjustment))
- mx_adjustment_get_value (vadjustment)) > 0)
{
CoglTextureVertex bottom[4] = { {0, }, };
if (len > shadow)
len = shadow;
bottom[0].x = w;
bottom[0].y = h;
bottom[1].y = h;
bottom[2].y = h - len;
bottom[3].x = w;
bottom[3].y = h - len;
cogl_color_set_from_4ub (&bottom[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&bottom[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&bottom[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&bottom[3].color, 0, 0, 0, 0);
cogl_polygon (bottom, 4, TRUE);
}
}
if (hadjustment)
{
gdouble len;
if ((len = mx_adjustment_get_value (hadjustment)) > 0)
{
CoglTextureVertex left[4] = { { 0, }, };
if (len > shadow)
len = shadow;
left[0].y = h;
left[2].x = len;
left[3].x = len;
left[3].y = h;
cogl_color_set_from_4ub (&left[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&left[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&left[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&left[3].color, 0, 0, 0, 0);
cogl_polygon (left, 4, TRUE);
}
if ((len = (mx_adjustment_get_upper (hadjustment)
- mx_adjustment_get_page_size (hadjustment))
- mx_adjustment_get_value (hadjustment)) > 0)
{
CoglTextureVertex right[4] = { { 0, }, };
if (len > shadow)
len = shadow;
right[0].x = w;
right[1].x = w;
right[1].y = h;
right[2].x = w - len;
right[2].y = h;
right[3].x = w - len;
cogl_color_set_from_4ub (&right[0].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&right[1].color, r, g, b, 0xff);
cogl_color_set_from_4ub (&right[2].color, 0, 0, 0, 0);
cogl_color_set_from_4ub (&right[3].color, 0, 0, 0, 0);
cogl_polygon (right, 4, TRUE);
}
}
}
static void
mnb_toolbar_background_paint_background (MxWidget *self,
ClutterActor *background,
const ClutterColor *color)
{
MnbToolbarBackgroundPrivate *priv = TOOLBAR_BACKGROUND_PRIVATE (self);
ClutterActor *actor = (ClutterActor *) self;
CoglHandle cogl_texture, cogl_material;
ClutterActorBox box = { 0, };
gfloat width, height;
gfloat tex_width, tex_height;
gfloat ex, ey;
gfloat tx1, ty1, tx2, ty2;
guint8 opacity;
/* Copied from MxWidget:
*
* Default implementation just draws the background
* colour and the image on top
*/
if (color && color->alpha != 0)
{
ClutterColor bg_color = *color;
bg_color.alpha = clutter_actor_get_paint_opacity (actor)
* bg_color.alpha
/ 255;
clutter_actor_get_allocation_box (actor, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
cogl_set_source_color4ub (bg_color.red,
bg_color.green,
bg_color.blue,
bg_color.alpha);
cogl_rectangle (0, 0, width, height);
}
/*
* Copied from MxTextureFrame
*/
/* no need to paint stuff if we don't have a texture */
if (G_UNLIKELY (priv->parent_texture == NULL))
return;
cogl_texture = clutter_texture_get_cogl_texture (priv->parent_texture);
if (cogl_texture == COGL_INVALID_HANDLE)
return;
cogl_material = clutter_texture_get_cogl_material (priv->parent_texture);
if (cogl_material == COGL_INVALID_HANDLE)
return;
tex_width = cogl_texture_get_width (cogl_texture);
tex_height = cogl_texture_get_height (cogl_texture);
clutter_actor_get_allocation_box (actor, &box);
width = box.x2 - box.x1;
height = box.y2 - box.y1;
opacity = clutter_actor_get_paint_opacity (actor);
/* Paint using the parent texture's material. It should already have
the cogl texture set as the first layer */
/* NB: for correct blending we need set a preumultiplied color here: */
cogl_material_set_color4ub (cogl_material,
opacity, opacity, opacity, opacity);
selector_texture = mnb_toolbar_get_selector_texture (priv->toolbar);
cogl_material_set_layer (cogl_material, 1, selector_texture);
cogl_material_set_layer_wrap_mode (cogl_material, 1,
COGL_MATERIAL_WRAP_MODE_CLAMP_TO_EDGE);
if (!cogl_material_set_layer_combine (cogl_material, 1,
"RGBA = MODULATE(PREVIOUS,TEXTURE)",
&error))
{
g_warning (G_STRLOC ": Error setting layer combine blend string: %s",
error->message);
g_error_free (error);
}
cogl_set_source (cogl_material);
/* simple stretch */
if (priv->left == 0 && priv->right == 0 && priv->top == 0
&& priv->bottom == 0)
{
float spot_width, spot_height;
float coords[8] = {
0, 0, 1, 1,
0, 0, 0, 0
};
mnb_toolbar_get_selector_allocation_box (priv->toolbar, &box);
spot_width = box.x2 - box.x1;
spot_height = box.y2 - box.y1;
coords[4] = -(box.x1 / width) * (width / spot_width);
coords[5] = -(box.y1 / height) * (height / spot_height);
coords[6] = width / spot_width - (box.x1 / width) * (width / spot_width);
coords[7] = height / spot_height - (box.y1 / height) * (height / spot_height);
cogl_rectangle_with_multitexture_coords (0, 0, width, height, coords, 8);
return;
}
tx1 = priv->left / tex_width;
tx2 = (tex_width - priv->right) / tex_width;
ty1 = priv->top / tex_height;
ty2 = (tex_height - priv->bottom) / tex_height;
ex = width - priv->right;
if (ex < priv->left)
ex = priv->left;
ey = height - priv->bottom;
if (ey < priv->top)
ey = priv->top;
{
GLfloat rectangles[] =
{
/* top left corner */
0, 0,
priv->left, priv->top,
0.0, 0.0,
tx1, ty1,
/* top middle */
priv->left, 0,
MAX (priv->left, ex), priv->top,
tx1, 0.0,
tx2, ty1,
/* top right */
ex, 0,
MAX (ex + priv->right, width), priv->top,
tx2, 0.0,
1.0, ty1,
/* mid left */
0, priv->top,
priv->left, ey,
0.0, ty1,
tx1, ty2,
/* center */
priv->left, priv->top,
ex, ey,
tx1, ty1,
tx2, ty2,
/* mid right */
ex, priv->top,
MAX (ex + priv->right, width), ey,
tx2, ty1,
1.0, ty2,
/* bottom left */
0, ey,
priv->left, MAX (ey + priv->bottom, height),
0.0, ty2,
tx1, 1.0,
/* bottom center */
priv->left, ey,
ex, MAX (ey + priv->bottom, height),
tx1, ty2,
tx2, 1.0,
/* bottom right */
ex, ey,
MAX (ex + priv->right, width), MAX (ey + priv->bottom, height),
tx2, ty2,
1.0, 1.0
};
cogl_rectangles_with_texture_coords (rectangles, 9);
}
}
static void
paint_test_backface_culling (TestState *state)
{
int draw_num;
CoglPipeline *base_pipeline = cogl_pipeline_new ();
CoglColor clear_color;
cogl_ortho (0, state->width, /* left, right */
state->height, 0, /* bottom, top */
-1, 100 /* z near, far */);
cogl_color_init_from_4ub (&clear_color, 0x00, 0x00, 0x00, 0xff);
cogl_clear (&clear_color, COGL_BUFFER_BIT_COLOR | COGL_BUFFER_BIT_STENCIL);
cogl_pipeline_set_layer_texture (base_pipeline, 0, state->texture);
cogl_pipeline_set_layer_filters (base_pipeline, 0,
COGL_PIPELINE_FILTER_NEAREST,
COGL_PIPELINE_FILTER_NEAREST);
/* Render the scene sixteen times to test all of the combinations of
cull face mode, legacy state and winding orders */
for (draw_num = 0; draw_num < 16; draw_num++)
{
float x1 = 0, x2, y1 = 0, y2 = (float)(TEXTURE_RENDER_SIZE);
CoglTextureVertex verts[4];
CoglPipeline *pipeline;
cogl_push_matrix ();
cogl_translate (0, TEXTURE_RENDER_SIZE * draw_num, 0);
pipeline = cogl_pipeline_copy (base_pipeline);
cogl_set_backface_culling_enabled (USE_LEGACY_STATE (draw_num));
cogl_pipeline_set_front_face_winding (pipeline, FRONT_WINDING (draw_num));
cogl_pipeline_set_cull_face_mode (pipeline, CULL_FACE_MODE (draw_num));
cogl_push_source (pipeline);
memset (verts, 0, sizeof (verts));
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a front-facing texture */
cogl_rectangle (x1, y1, x2, y2);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a front-facing texture with flipped texcoords */
cogl_rectangle_with_texture_coords (x1, y1, x2, y2,
1.0, 0.0, 0.0, 1.0);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a back-facing texture */
cogl_rectangle (x2, y1, x1, y2);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* If the texture is sliced then cogl_polygon doesn't work so
we'll just use a solid color instead */
if (cogl_texture_is_sliced (state->texture))
cogl_set_source_color4ub (255, 0, 0, 255);
/* Draw a front-facing polygon */
verts[0].x = x1; verts[0].y = y2;
verts[1].x = x2; verts[1].y = y2;
verts[2].x = x2; verts[2].y = y1;
verts[3].x = x1; verts[3].y = y1;
verts[0].tx = 0; verts[0].ty = 0;
verts[1].tx = 1.0; verts[1].ty = 0;
verts[2].tx = 1.0; verts[2].ty = 1.0;
verts[3].tx = 0; verts[3].ty = 1.0;
cogl_polygon (verts, 4, FALSE);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
/* Draw a back-facing polygon */
verts[0].x = x1; verts[0].y = y1;
verts[1].x = x2; verts[1].y = y1;
verts[2].x = x2; verts[2].y = y2;
verts[3].x = x1; verts[3].y = y2;
verts[0].tx = 0; verts[0].ty = 0;
verts[1].tx = 1.0; verts[1].ty = 0;
verts[2].tx = 1.0; verts[2].ty = 1.0;
verts[3].tx = 0; verts[3].ty = 1.0;
cogl_polygon (verts, 4, FALSE);
x1 = x2;
x2 = x1 + (float)(TEXTURE_RENDER_SIZE);
cogl_pop_matrix ();
cogl_pop_source ();
cogl_object_unref (pipeline);
}
cogl_object_unref (base_pipeline);
}
static CoglBool
draw_rectangle (TestState *state,
int x,
int y,
TestDepthState *rect_state,
CoglBool legacy_mode)
{
uint8_t Cr = MASK_RED (rect_state->color);
uint8_t Cg = MASK_GREEN (rect_state->color);
uint8_t Cb = MASK_BLUE (rect_state->color);
uint8_t Ca = MASK_ALPHA (rect_state->color);
CoglPipeline *pipeline;
CoglDepthState depth_state;
cogl_depth_state_init (&depth_state);
cogl_depth_state_set_test_enabled (&depth_state, rect_state->test_enable);
cogl_depth_state_set_test_function (&depth_state, rect_state->test_function);
cogl_depth_state_set_write_enabled (&depth_state, rect_state->write_enable);
cogl_depth_state_set_range (&depth_state,
rect_state->range_near,
rect_state->range_far);
pipeline = cogl_pipeline_new (test_ctx);
if (!cogl_pipeline_set_depth_state (pipeline, &depth_state, NULL))
{
cogl_object_unref (pipeline);
return FALSE;
}
if (!legacy_mode)
{
cogl_pipeline_set_color4ub (pipeline, Cr, Cg, Cb, Ca);
cogl_framebuffer_set_depth_write_enabled (test_fb,
rect_state->fb_write_enable);
cogl_framebuffer_push_matrix (test_fb);
cogl_framebuffer_translate (test_fb, 0, 0, rect_state->depth);
cogl_framebuffer_draw_rectangle (test_fb,
pipeline,
x * QUAD_WIDTH,
y * QUAD_WIDTH,
x * QUAD_WIDTH + QUAD_WIDTH,
y * QUAD_WIDTH + QUAD_WIDTH);
cogl_framebuffer_pop_matrix (test_fb);
}
else
{
cogl_push_framebuffer (test_fb);
cogl_push_matrix ();
cogl_set_source_color4ub (Cr, Cg, Cb, Ca);
cogl_translate (0, 0, rect_state->depth);
cogl_rectangle (x * QUAD_WIDTH,
y * QUAD_WIDTH,
x * QUAD_WIDTH + QUAD_WIDTH,
y * QUAD_WIDTH + QUAD_WIDTH);
cogl_pop_matrix ();
cogl_pop_framebuffer ();
}
cogl_object_unref (pipeline);
return TRUE;
}
static void
on_paint (ClutterActor *actor, CallbackData *data)
{
int i;
ClutterGeometry stage_size;
gint hand_width, hand_height;
GSList *node;
clutter_actor_get_allocation_geometry (data->stage, &stage_size);
hand_width = cogl_texture_get_width (data->hand);
hand_height = cogl_texture_get_height (data->hand);
/* Setup the clipping */
for (node = data->clips; node; node = node->next)
{
Clip *clip = (Clip *) node->data;
if (clip->type == CLIP_RECTANGLE)
cogl_clip_push_rectangle (clip->x1,
clip->y1,
clip->x2,
clip->y2);
else if (clip->type == CLIP_ROTATED_RECTANGLE)
{
float size = MIN (ABS (clip->x2 - clip->x1),
ABS (clip->y2 - clip->y1));
int cx = (clip->x1 + clip->x2) / 2;
int cy = (clip->y1 + clip->y2) / 2;
size = sqrtf ((size / 2) * (size / 2) * 2);
cogl_push_matrix ();
/* Rotate 45° about the centre point */
cogl_translate (cx, cy, 0.0f);
cogl_rotate (45.0f, 0.0f, 0.0f, 1.0f);
cogl_clip_push_rectangle (-size / 2, -size / 2, size / 2, size / 2);
cogl_pop_matrix ();
}
else
{
make_clip_path (clip);
cogl_clip_push_from_path ();
}
}
/* Draw a rectangle filling the entire stage */
cogl_set_source_color4ub (0x80, 0x80, 0xff, 0xff);
cogl_rectangle (0, 0, stage_size.width, stage_size.height);
draw_shapes (10, 10);
/* Draw the hand at different rotations */
for (i = -2; i <= 2; i++)
{
cogl_push_matrix ();
cogl_translate (stage_size.width / 2 + stage_size.width / 6 * i,
stage_size.height / 2, 0);
cogl_rotate (i * 40, 0, 1, 0);
cogl_set_source_color4ub (0xff, 0xff, 0xff, 0xff);
cogl_set_source_texture (data->hand);
cogl_rectangle_with_texture_coords ((-hand_width / 2),
(-hand_height / 2),
(hand_width / 2),
(hand_height / 2),
0, 0, 1, 1);
cogl_pop_matrix ();
}
draw_shapes (stage_size.width - 310, stage_size.height - 110);
/* Remove all of the clipping */
g_slist_foreach (data->clips, (GFunc) cogl_clip_pop, NULL);
/* Draw the bounding box for each of the clips */
for (node = data->clips; node; node = node->next)
{
Clip *clip = (Clip *) node->data;
make_clip_path (clip);
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_path_stroke ();
}
/* Draw the bounding box for the pending new clip */
if (data->current_clip.type != CLIP_NONE)
{
make_clip_path (&data->current_clip);
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_path_stroke ();
}
}
static void
on_paint (ClutterActor *actor, void *state)
{
float saved_viewport[4];
CoglMatrix saved_projection;
CoglMatrix projection;
CoglMatrix modelview;
guchar *data;
CoglHandle tex;
CoglHandle offscreen;
CoglColor black;
float x0;
float y0;
float width;
float height;
/* for clearing the offscreen framebuffer to black... */
cogl_color_init_from_4ub (&black, 0x00, 0x00, 0x00, 0xff);
cogl_get_viewport (saved_viewport);
cogl_get_projection_matrix (&saved_projection);
cogl_push_matrix ();
cogl_matrix_init_identity (&projection);
cogl_matrix_init_identity (&modelview);
cogl_set_projection_matrix (&projection);
cogl_set_modelview_matrix (&modelview);
/* - Create a 100x200 viewport (i.e. smaller than the onscreen framebuffer)
* and position it a (20, 10) inside the framebuffer.
* - Fill the whole viewport with a purple rectangle
* - Verify that the framebuffer is black with a 100x200 purple rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
100, /* width */
200); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* fill the viewport with purple.. */
cogl_set_source_color4ub (0xff, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0xff, 0x00, 0xff);
/* - Create a viewport twice the size of the onscreen framebuffer with
* a negative offset positioning it at (-20, -10) relative to the
* buffer itself.
* - Draw a 100x200 green rectangle at (40, 20) within the viewport (which
* is (20, 10) within the framebuffer)
* - Verify that the framebuffer is black with a 100x200 green rectangle at
* (20, 10)
*/
cogl_set_viewport (-20, /* x */
-10, /* y */
FRAMEBUFFER_WIDTH * 2, /* width */
FRAMEBUFFER_HEIGHT * 2); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* draw a 100x200 green rectangle offset into the viewport such that its
* top left corner should be found at (20, 10) in the offscreen buffer */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (1.0f / FRAMEBUFFER_WIDTH) * 40.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (1.0f / FRAMEBUFFER_HEIGHT) * 20.0f;
width = (1.0f / FRAMEBUFFER_WIDTH) * 100;
height = (1.0f / FRAMEBUFFER_HEIGHT) * 200;
cogl_set_source_color4ub (0x00, 0xff, 0x00, 0xff);
cogl_rectangle (x0, y0, x0 + width, y0 - height);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0xff, 0x00);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 window space clip rectangle at (20, 10)
* - Fill the whole viewport with a blue rectangle
* - Verify that the framebuffer is black with a 100x200 blue rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_clip_push_window_rectangle (20, 10, 100, 200);
/* fill the viewport with blue.. */
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0x00, 0xff);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 model space clip rectangle at (20, 10) in the viewport
* (i.e. (40, 20) inside the framebuffer)
* - Fill the whole viewport with a green rectangle
* - Verify that the framebuffer is black with a 100x200 green rectangle at
* (40, 20)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* figure out where to position our clip rectangle in model space
* coordinates... */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (2.0f / 200) * 20.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (2.0f / 400) * 10.0f;
width = (2.0f / 200) * 100;
height = (2.0f / 400) * 200;
/* add the clip rectangle... */
cogl_push_matrix ();
cogl_translate (x0 + (width/2.0), y0 - (height/2.0), 0);
/* XXX: Rotate just enough to stop Cogl from converting our model space
* rectangle into a window space rectangle.. */
cogl_rotate (0.1, 0, 0, 1);
cogl_clip_push_rectangle (-(width/2.0), -(height/2.0),
width/2.0, height/2.0);
cogl_pop_matrix ();
/* fill the viewport with green.. */
cogl_set_source_color4ub (0x00, 0xff, 0x00, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (40, 20, 100, 200,
0x00, 0xff, 0x00);
/* Set the viewport to something specific so we can verify that it gets
* restored after we are done testing with an offscreen framebuffer... */
cogl_set_viewport (20, 10, 100, 200);
/*
* Next test offscreen drawing...
*/
data = g_malloc (FRAMEBUFFER_WIDTH * 4 * FRAMEBUFFER_HEIGHT);
tex = cogl_texture_new_from_data (FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT,
COGL_TEXTURE_NO_SLICING,
COGL_PIXEL_FORMAT_RGBA_8888, /* data fmt */
COGL_PIXEL_FORMAT_ANY, /* internal fmt */
FRAMEBUFFER_WIDTH * 4, /* rowstride */
data);
g_free (data);
offscreen = cogl_offscreen_new_to_texture (tex);
cogl_push_framebuffer (offscreen);
/* - Create a 100x200 viewport (i.e. smaller than the offscreen framebuffer)
* and position it a (20, 10) inside the framebuffer.
* - Fill the whole viewport with a blue rectangle
* - Verify that the framebuffer is black with a 100x200 blue rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
100, /* width */
200); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* fill the viewport with blue.. */
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0x00, 0xff);
/* - Create a viewport twice the size of the offscreen framebuffer with
* a negative offset positioning it at (-20, -10) relative to the
* buffer itself.
* - Draw a 100x200 red rectangle at (40, 20) within the viewport (which
* is (20, 10) within the framebuffer)
* - Verify that the framebuffer is black with a 100x200 red rectangle at
* (20, 10)
*/
cogl_set_viewport (-20, /* x */
-10, /* y */
FRAMEBUFFER_WIDTH * 2, /* width */
FRAMEBUFFER_HEIGHT * 2); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* draw a 100x200 red rectangle offset into the viewport such that its
* top left corner should be found at (20, 10) in the offscreen buffer */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (1.0f / FRAMEBUFFER_WIDTH) * 40.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (1.0f / FRAMEBUFFER_HEIGHT) * 20.0f;
width = (1.0f / FRAMEBUFFER_WIDTH) * 100;
height = (1.0f / FRAMEBUFFER_HEIGHT) * 200;
cogl_set_source_color4ub (0xff, 0x00, 0x00, 0xff);
cogl_rectangle (x0, y0, x0 + width, y0 - height);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0xff, 0x00, 0x00);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 window space clip rectangle at (20, 10)
* - Fill the whole viewport with a blue rectangle
* - Verify that the framebuffer is black with a 100x200 blue rectangle at
* (20, 10)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_clip_push_window_rectangle (20, 10, 100, 200);
/* fill the viewport with blue.. */
cogl_set_source_color4ub (0x00, 0x00, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0x00, 0x00, 0xff);
/* - Create a 200x400 viewport and position it a (20, 10) inside the draw
* buffer.
* - Push a 100x200 model space clip rectangle at (20, 10) in the viewport
* (i.e. (40, 20) inside the framebuffer)
* - Fill the whole viewport with a green rectangle
* - Verify that the framebuffer is black with a 100x200 green rectangle at
* (40, 20)
*/
cogl_set_viewport (20, /* x */
10, /* y */
200, /* width */
400); /* height */
/* clear everything... */
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
/* figure out where to position our clip rectangle in model space
* coordinates... */
/* (offset 40 pixels right from the left of the viewport) */
x0 = -1.0f + (2.0f / 200) * 20.f;
/* (offset 20 pixels down from the top of the viewport) */
y0 = 1.0f - (2.0f / 400) * 10.0f;
width = (2.0f / 200) * 100;
height = (2.0f / 400) * 200;
/* add the clip rectangle... */
cogl_push_matrix ();
cogl_translate (x0 + (width/2.0), y0 - (height/2.0), 0);
/* XXX: Rotate just enough to stop Cogl from converting our model space
* rectangle into a window space rectangle.. */
cogl_rotate (0.1, 0, 0, 1);
cogl_clip_push_rectangle (-(width/2.0), -(height/2.0),
width/2, height/2);
cogl_pop_matrix ();
/* fill the viewport with green.. */
cogl_set_source_color4ub (0x00, 0xff, 0x00, 0xff);
cogl_rectangle (-1, 1, 1, -1);
cogl_clip_pop ();
assert_rectangle_color_and_black_border (40, 20, 100, 200,
0x00, 0xff, 0x00);
/* Set the viewport to something obscure to verify that it gets
* replace when we switch back to the onscreen framebuffer... */
cogl_set_viewport (0, 0, 10, 10);
cogl_pop_framebuffer ();
cogl_handle_unref (offscreen);
/*
* Verify that the previous onscreen framebuffer's viewport was restored
* by drawing a white rectangle across the whole viewport. This should
* draw a 100x200 rectangle at (20,10) relative to the onscreen draw
* buffer...
*/
cogl_clear (&black, COGL_BUFFER_BIT_COLOR);
cogl_set_source_color4ub (0xff, 0xff, 0xff, 0xff);
cogl_rectangle (-1, 1, 1, -1);
assert_rectangle_color_and_black_border (20, 10, 100, 200,
0xff, 0xff, 0xff);
/* Uncomment to display the last contents of the offscreen framebuffer */
#if 1
cogl_matrix_init_identity (&projection);
cogl_matrix_init_identity (&modelview);
cogl_set_viewport (0, 0, FRAMEBUFFER_WIDTH, FRAMEBUFFER_HEIGHT);
cogl_set_projection_matrix (&projection);
cogl_set_modelview_matrix (&modelview);
cogl_set_source_texture (tex);
cogl_rectangle (-1, 1, 1, -1);
#endif
cogl_handle_unref (tex);
/* Finally restore the stage's original state... */
cogl_pop_matrix ();
cogl_set_projection_matrix (&saved_projection);
cogl_set_viewport (saved_viewport[0], saved_viewport[1],
saved_viewport[2], saved_viewport[3]);
/* Comment this out if you want visual feedback of what this test
* paints.
*/
clutter_main_quit ();
}
static void
clutter_rectangle_paint (ClutterActor *self)
{
ClutterRectanglePrivate *priv = CLUTTER_RECTANGLE (self)->priv;
ClutterGeometry geom;
guint8 tmp_alpha;
CLUTTER_NOTE (PAINT,
"painting rect '%s'",
clutter_actor_get_name (self) ? clutter_actor_get_name (self)
: "unknown");
clutter_actor_get_allocation_geometry (self, &geom);
if (priv->has_border)
{
/* We paint the border and the content only if the rectangle
* is big enough to show them
*/
if ((priv->border_width * 2) < geom.width &&
(priv->border_width * 2) < geom.height)
{
/* compute the composited opacity of the actor taking into
* account the opacity of the color set by the user
*/
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->border_color.alpha
/ 255;
/* paint the border */
cogl_set_source_color4ub (priv->border_color.red,
priv->border_color.green,
priv->border_color.blue,
tmp_alpha);
/* this sucks, but it's the only way to make a border */
cogl_rectangle (priv->border_width, 0,
geom.width,
priv->border_width);
cogl_rectangle (geom.width - priv->border_width,
priv->border_width,
geom.width,
geom.height);
cogl_rectangle (0, geom.height - priv->border_width,
geom.width - priv->border_width,
geom.height);
cogl_rectangle (0, 0,
priv->border_width,
geom.height - priv->border_width);
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->color.alpha
/ 255;
/* now paint the rectangle */
cogl_set_source_color4ub (priv->color.red,
priv->color.green,
priv->color.blue,
tmp_alpha);
cogl_rectangle (priv->border_width, priv->border_width,
geom.width - priv->border_width,
geom.height - priv->border_width);
}
else
{
/* Otherwise, we draw a rectangle with the same color
* as the border, since we can only fit that into the
* allocation.
*/
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->border_color.alpha
/ 255;
cogl_set_source_color4ub (priv->border_color.red,
priv->border_color.green,
priv->border_color.blue,
tmp_alpha);
cogl_rectangle (0, 0, geom.width, geom.height);
}
}
else
{
/* compute the composited opacity of the actor taking into
* account the opacity of the color set by the user
*/
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->color.alpha
/ 255;
cogl_set_source_color4ub (priv->color.red,
priv->color.green,
priv->color.blue,
tmp_alpha);
cogl_rectangle (0, 0, geom.width, geom.height);
}
}
static void
clutter_rectangle_paint (ClutterActor *self)
{
ClutterRectanglePrivate *priv = CLUTTER_RECTANGLE (self)->priv;
ClutterGeometry geom;
guint8 tmp_alpha;
CLUTTER_NOTE (PAINT,
"painting rect '%s'",
clutter_actor_get_name (self) ? clutter_actor_get_name (self)
: "unknown");
clutter_actor_get_allocation_geometry (self, &geom);
/* parent paint call will have translated us into position so
* paint from 0, 0
*/
if (priv->has_border)
{
/* compute the composited opacity of the actor taking into
* account the opacity of the color set by the user
*/
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->border_color.alpha
/ 255;
/* paint the border */
cogl_set_source_color4ub (priv->border_color.red,
priv->border_color.green,
priv->border_color.blue,
tmp_alpha);
/* this sucks, but it's the only way to make a border */
cogl_rectangle (priv->border_width, 0,
geom.width,
priv->border_width);
cogl_rectangle (geom.width - priv->border_width,
priv->border_width,
geom.width,
geom.height);
cogl_rectangle (0, geom.height - priv->border_width,
geom.width - priv->border_width,
geom.height);
cogl_rectangle (0, 0,
priv->border_width,
geom.height - priv->border_width);
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->color.alpha
/ 255;
/* now paint the rectangle */
cogl_set_source_color4ub (priv->color.red,
priv->color.green,
priv->color.blue,
tmp_alpha);
cogl_rectangle (priv->border_width, priv->border_width,
geom.width - priv->border_width,
geom.height - priv->border_width);
}
else
{
/* compute the composited opacity of the actor taking into
* account the opacity of the color set by the user
*/
tmp_alpha = clutter_actor_get_paint_opacity (self)
* priv->color.alpha
/ 255;
cogl_set_source_color4ub (priv->color.red,
priv->color.green,
priv->color.blue,
tmp_alpha);
cogl_rectangle (0, 0, geom.width, geom.height);
}
}
