static gboolean
gtk_css_image_linear_equal (GtkCssImage *image1,
GtkCssImage *image2)
{
GtkCssImageLinear *linear1 = GTK_CSS_IMAGE_LINEAR (image1);
GtkCssImageLinear *linear2 = GTK_CSS_IMAGE_LINEAR (image2);
guint i;
if (linear1->repeating != linear2->repeating ||
linear1->side != linear2->side ||
(linear1->side == 0 && !_gtk_css_value_equal (linear1->angle, linear2->angle)) ||
linear1->stops->len != linear2->stops->len)
return FALSE;
for (i = 0; i < linear1->stops->len; i++)
{
GtkCssImageLinearColorStop *stop1, *stop2;
stop1 = &g_array_index (linear1->stops, GtkCssImageLinearColorStop, i);
stop2 = &g_array_index (linear2->stops, GtkCssImageLinearColorStop, i);
if (!_gtk_css_value_equal0 (stop1->offset, stop2->offset) ||
!_gtk_css_value_equal (stop1->color, stop2->color))
return FALSE;
}
return TRUE;
}
static void
gtk_css_image_linear_print (GtkCssImage *image,
GString *string)
{
GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
guint i;
if (linear->repeating)
g_string_append (string, "repeating-linear-gradient(");
else
g_string_append (string, "linear-gradient(");
if (_gtk_css_number_value_get_unit (linear->angle) == GTK_CSS_NUMBER)
{
guint side = _gtk_css_number_value_get (linear->angle, 100);
if (side != (1 << GTK_CSS_BOTTOM))
{
g_string_append (string, "to");
if (side & (1 << GTK_CSS_TOP))
g_string_append (string, " top");
else if (side & (1 << GTK_CSS_BOTTOM))
g_string_append (string, " bottom");
if (side & (1 << GTK_CSS_LEFT))
g_string_append (string, " left");
else if (side & (1 << GTK_CSS_RIGHT))
g_string_append (string, " right");
g_string_append (string, ", ");
}
}
else
{
_gtk_css_value_print (linear->angle, string);
g_string_append (string, ", ");
}
for (i = 0; i < linear->stops->len; i++)
{
GtkCssImageLinearColorStop *stop;
if (i > 0)
g_string_append (string, ", ");
stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
_gtk_css_value_print (stop->color, string);
if (stop->offset)
{
g_string_append (string, " ");
_gtk_css_value_print (stop->offset, string);
}
}
g_string_append (string, ")");
}
static void
gtk_css_image_linear_dispose (GObject *object)
{
GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (object);
if (linear->stops)
{
g_array_free (linear->stops, TRUE);
linear->stops = NULL;
}
if (linear->angle)
{
_gtk_css_value_unref (linear->angle);
linear->angle = NULL;
}
G_OBJECT_CLASS (_gtk_css_image_linear_parent_class)->dispose (object);
}
static GtkCssImage *
gtk_css_image_linear_compute (GtkCssImage *image,
guint property_id,
GtkStyleProviderPrivate *provider,
GtkCssStyle *style,
GtkCssStyle *parent_style)
{
GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
GtkCssImageLinear *copy;
guint i;
copy = g_object_new (GTK_TYPE_CSS_IMAGE_LINEAR, NULL);
copy->repeating = linear->repeating;
copy->side = linear->side;
if (linear->angle)
copy->angle = _gtk_css_value_compute (linear->angle, property_id, provider, style, parent_style);
g_array_set_size (copy->stops, linear->stops->len);
for (i = 0; i < linear->stops->len; i++)
{
GtkCssImageLinearColorStop *stop, *scopy;
stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
scopy = &g_array_index (copy->stops, GtkCssImageLinearColorStop, i);
scopy->color = _gtk_css_value_compute (stop->color, property_id, provider, style, parent_style);
if (stop->offset)
{
scopy->offset = _gtk_css_value_compute (stop->offset, property_id, provider, style, parent_style);
}
else
{
scopy->offset = NULL;
}
}
return GTK_CSS_IMAGE (copy);
}
static GtkCssImage *
gtk_css_image_linear_transition (GtkCssImage *start_image,
GtkCssImage *end_image,
guint property_id,
double progress)
{
GtkCssImageLinear *start, *end, *result;
guint i;
start = GTK_CSS_IMAGE_LINEAR (start_image);
if (end_image == NULL)
return GTK_CSS_IMAGE_CLASS (_gtk_css_image_linear_parent_class)->transition (start_image, end_image, property_id, progress);
if (!GTK_IS_CSS_IMAGE_LINEAR (end_image))
return GTK_CSS_IMAGE_CLASS (_gtk_css_image_linear_parent_class)->transition (start_image, end_image, property_id, progress);
end = GTK_CSS_IMAGE_LINEAR (end_image);
if ((start->repeating != end->repeating)
|| (start->stops->len != end->stops->len))
return GTK_CSS_IMAGE_CLASS (_gtk_css_image_linear_parent_class)->transition (start_image, end_image, property_id, progress);
result = g_object_new (GTK_TYPE_CSS_IMAGE_LINEAR, NULL);
result->repeating = start->repeating;
if (start->side != end->side)
goto fail;
result->side = start->side;
if (result->side == 0)
result->angle = _gtk_css_value_transition (start->angle, end->angle, property_id, progress);
if (result->angle == NULL)
goto fail;
for (i = 0; i < start->stops->len; i++)
{
GtkCssImageLinearColorStop stop, *start_stop, *end_stop;
start_stop = &g_array_index (start->stops, GtkCssImageLinearColorStop, i);
end_stop = &g_array_index (end->stops, GtkCssImageLinearColorStop, i);
if ((start_stop->offset != NULL) != (end_stop->offset != NULL))
goto fail;
if (start_stop->offset == NULL)
{
stop.offset = NULL;
}
else
{
stop.offset = _gtk_css_value_transition (start_stop->offset,
end_stop->offset,
property_id,
progress);
if (stop.offset == NULL)
goto fail;
}
stop.color = _gtk_css_value_transition (start_stop->color,
end_stop->color,
property_id,
progress);
if (stop.color == NULL)
{
if (stop.offset)
_gtk_css_value_unref (stop.offset);
goto fail;
}
g_array_append_val (result->stops, stop);
}
return GTK_CSS_IMAGE (result);
fail:
g_object_unref (result);
return GTK_CSS_IMAGE_CLASS (_gtk_css_image_linear_parent_class)->transition (start_image, end_image, property_id, progress);
}
static gboolean
gtk_css_image_linear_parse (GtkCssImage *image,
GtkCssParser *parser)
{
GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
guint i;
if (_gtk_css_parser_try (parser, "repeating-linear-gradient(", TRUE))
linear->repeating = TRUE;
else if (_gtk_css_parser_try (parser, "linear-gradient(", TRUE))
linear->repeating = FALSE;
else
{
_gtk_css_parser_error (parser, "Not a linear gradient");
return FALSE;
}
if (_gtk_css_parser_try (parser, "to", TRUE))
{
for (i = 0; i < 2; i++)
{
if (_gtk_css_parser_try (parser, "left", TRUE))
{
if (linear->side & ((1 << GTK_CSS_LEFT) | (1 << GTK_CSS_RIGHT)))
{
_gtk_css_parser_error (parser, "Expected 'top', 'bottom' or comma");
return FALSE;
}
linear->side |= (1 << GTK_CSS_LEFT);
}
else if (_gtk_css_parser_try (parser, "right", TRUE))
{
if (linear->side & ((1 << GTK_CSS_LEFT) | (1 << GTK_CSS_RIGHT)))
{
_gtk_css_parser_error (parser, "Expected 'top', 'bottom' or comma");
return FALSE;
}
linear->side |= (1 << GTK_CSS_RIGHT);
}
else if (_gtk_css_parser_try (parser, "top", TRUE))
{
if (linear->side & ((1 << GTK_CSS_TOP) | (1 << GTK_CSS_BOTTOM)))
{
_gtk_css_parser_error (parser, "Expected 'left', 'right' or comma");
return FALSE;
}
linear->side |= (1 << GTK_CSS_TOP);
}
else if (_gtk_css_parser_try (parser, "bottom", TRUE))
{
if (linear->side & ((1 << GTK_CSS_TOP) | (1 << GTK_CSS_BOTTOM)))
{
_gtk_css_parser_error (parser, "Expected 'left', 'right' or comma");
return FALSE;
}
linear->side |= (1 << GTK_CSS_BOTTOM);
}
else
break;
}
if (linear->side == 0)
{
_gtk_css_parser_error (parser, "Expected side that gradient should go to");
return FALSE;
}
if (!_gtk_css_parser_try (parser, ",", TRUE))
{
_gtk_css_parser_error (parser, "Expected a comma");
return FALSE;
}
}
else if (gtk_css_number_value_can_parse (parser))
{
linear->angle = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
if (linear->angle == NULL)
return FALSE;
if (!_gtk_css_parser_try (parser, ",", TRUE))
{
_gtk_css_parser_error (parser, "Expected a comma");
return FALSE;
}
}
else
linear->side = 1 << GTK_CSS_BOTTOM;
do {
GtkCssImageLinearColorStop stop;
stop.color = _gtk_css_color_value_parse (parser);
if (stop.color == NULL)
return FALSE;
if (gtk_css_number_value_can_parse (parser))
{
stop.offset = _gtk_css_number_value_parse (parser,
GTK_CSS_PARSE_PERCENT
| GTK_CSS_PARSE_LENGTH);
if (stop.offset == NULL)
{
_gtk_css_value_unref (stop.color);
return FALSE;
}
}
else
{
stop.offset = NULL;
}
g_array_append_val (linear->stops, stop);
} while (_gtk_css_parser_try (parser, ",", TRUE));
if (linear->stops->len < 2)
{
_gtk_css_parser_error_full (parser,
GTK_CSS_PROVIDER_ERROR_DEPRECATED,
"Using one color stop with %s() is deprecated.",
linear->repeating ? "repeating-linear-gradient" : "linear-gradient");
}
if (!_gtk_css_parser_try (parser, ")", TRUE))
{
_gtk_css_parser_error (parser, "Missing closing bracket at end of linear gradient");
return FALSE;
}
return TRUE;
}
static void
gtk_css_image_linear_snapshot (GtkCssImage *image,
GtkSnapshot *snapshot,
double width,
double height)
{
GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
GskColorStop *stops;
GskRenderNode *node;
double off_x, off_y; /* snapshot offset */
double angle; /* actual angle of the gradiant line in degrees */
double x, y; /* coordinates of start point */
double length; /* distance in pixels for 100% */
double start, end; /* position of first/last point on gradient line - with gradient line being [0, 1] */
double offset;
int i, last;
char *name;
if (linear->side)
{
/* special casing the regular cases here so we don't get rounding errors */
switch (linear->side)
{
case 1 << GTK_CSS_RIGHT:
angle = 90;
break;
case 1 << GTK_CSS_LEFT:
angle = 270;
break;
case 1 << GTK_CSS_TOP:
angle = 0;
break;
case 1 << GTK_CSS_BOTTOM:
angle = 180;
break;
default:
angle = atan2 (linear->side & 1 << GTK_CSS_TOP ? -width : width,
linear->side & 1 << GTK_CSS_LEFT ? -height : height);
angle = 180 * angle / G_PI + 90;
break;
}
}
else
{
angle = _gtk_css_number_value_get (linear->angle, 100);
}
gtk_css_image_linear_compute_start_point (angle,
width, height,
&x, &y);
length = sqrt (x * x + y * y);
gtk_css_image_linear_get_start_end (linear, length, &start, &end);
if (start == end)
{
/* repeating gradients with all color stops sharing the same offset
* get the color of the last color stop */
GtkCssImageLinearColorStop *stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, linear->stops->len - 1);
gtk_snapshot_append_color_node (snapshot,
_gtk_css_rgba_value_get_rgba (stop->color),
&GRAPHENE_RECT_INIT (0, 0, width, height),
"RepeatingLinearGradient<degenerate>");
return;
}
offset = start;
last = -1;
stops = g_newa (GskColorStop, linear->stops->len);
for (i = 0; i < linear->stops->len; i++)
{
GtkCssImageLinearColorStop *stop;
double pos, step;
stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
if (stop->offset == NULL)
{
if (i == 0)
pos = 0.0;
else if (i + 1 == linear->stops->len)
pos = 1.0;
else
continue;
}
else
pos = _gtk_css_number_value_get (stop->offset, length) / length;
pos = MAX (pos, offset);
step = (pos - offset) / (i - last);
for (last = last + 1; last <= i; last++)
{
stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, last);
offset += step;
stops[last].offset = (offset - start) / (end - start);
stops[last].color = *_gtk_css_rgba_value_get_rgba (stop->color);
}
offset = pos;
last = i;
}
gtk_snapshot_get_offset (snapshot, &off_x, &off_y);
if (linear->repeating)
{
node = gsk_repeating_linear_gradient_node_new (
&GRAPHENE_RECT_INIT (off_x, off_y, width, height),
&GRAPHENE_POINT_INIT (off_x + width / 2 + x * (start - 0.5), off_y + height / 2 + y * (start - 0.5)),
&GRAPHENE_POINT_INIT (off_x + width / 2 + x * (end - 0.5), off_y + height / 2 + y * (end - 0.5)),
stops,
linear->stops->len);
}
else
{
node = gsk_linear_gradient_node_new (
&GRAPHENE_RECT_INIT (off_x, off_y, width, height),
&GRAPHENE_POINT_INIT (off_x + width / 2 + x * (start - 0.5), off_y + height / 2 + y * (start - 0.5)),
&GRAPHENE_POINT_INIT (off_x + width / 2 + x * (end - 0.5), off_y + height / 2 + y * (end - 0.5)),
stops,
linear->stops->len);
}
name = g_strdup_printf ("%sLinearGradient<%ustops>", linear->repeating ? "Repeating" : "", linear->stops->len);
gsk_render_node_set_name (node, name);
g_free (name);
gtk_snapshot_append_node (snapshot, node);
gsk_render_node_unref (node);
}
static void
gtk_css_image_linear_draw (GtkCssImage *image,
cairo_t *cr,
double width,
double height)
{
GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
cairo_pattern_t *pattern;
double angle; /* actual angle of the gradiant line in degrees */
double x, y; /* coordinates of start point */
double length; /* distance in pixels for 100% */
double start, end; /* position of first/last point on gradient line - with gradient line being [0, 1] */
double offset;
int i, last;
if (linear->side)
{
/* special casing the regular cases here so we don't get rounding errors */
switch (linear->side)
{
case 1 << GTK_CSS_RIGHT:
angle = 90;
break;
case 1 << GTK_CSS_LEFT:
angle = 270;
break;
case 1 << GTK_CSS_TOP:
angle = 0;
break;
case 1 << GTK_CSS_BOTTOM:
angle = 180;
break;
default:
angle = atan2 (linear->side & 1 << GTK_CSS_TOP ? -width : width,
linear->side & 1 << GTK_CSS_LEFT ? -height : height);
angle = 180 * angle / G_PI + 90;
break;
}
}
else
{
angle = _gtk_css_number_value_get (linear->angle, 100);
}
gtk_css_image_linear_compute_start_point (angle,
width, height,
&x, &y);
length = sqrt (x * x + y * y);
gtk_css_image_linear_get_start_end (linear, length, &start, &end);
pattern = cairo_pattern_create_linear (x * (start - 0.5), y * (start - 0.5),
x * (end - 0.5), y * (end - 0.5));
if (linear->repeating)
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
else
cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
offset = start;
last = -1;
for (i = 0; i < linear->stops->len; i++)
{
GtkCssImageLinearColorStop *stop;
double pos, step;
stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
if (stop->offset == NULL)
{
if (i == 0)
pos = 0.0;
else if (i + 1 == linear->stops->len)
pos = 1.0;
else
continue;
}
else
pos = _gtk_css_number_value_get (stop->offset, length) / length;
pos = MAX (pos, offset);
step = (pos - offset) / (i - last);
for (last = last + 1; last <= i; last++)
{
const GdkRGBA *rgba;
stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, last);
rgba = _gtk_css_rgba_value_get_rgba (stop->color);
offset += step;
cairo_pattern_add_color_stop_rgba (pattern,
(offset - start) / (end - start),
rgba->red,
rgba->green,
rgba->blue,
rgba->alpha);
}
offset = pos;
last = i;
}
cairo_rectangle (cr, 0, 0, width, height);
cairo_translate (cr, width / 2, height / 2);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
