forked from AuroraMiddleware/gtk
1454ba15ba
Here's the shortest description of the bug I can come up with:
When computing values, we have 3 kinds of dependencies:
(1) other properties ("currentColor" or em values)
(2) inherited properties ("inherit")
(3) generic things from the theme (@keyframes or @define-color)
Previously, we passed the GtkStyleContext as an argument, because it
provided these 3 things using:
(1) _gtk_style_context_peek_property()
(2) _gtk_style_context_peek_property(gtk_style_context_get_parent())
(3) context->priv->cascade
However, this makes it impossible to lookup values other than the ones
accessible via _gtk_style_context_peek_property(). And this is exactly
what we are doing in gtk_style_context_update_cache(). So when the cache
updates encountered case (1), they were looking up the values from the
wrong style data.
So this large patch essentially does nothing but replace the
context argument in all compute functions with new arguments for the 3
cases above:
(1) values
(2) parent_values
(3) provider
We apparently have a lot of computing code.
441 lines
12 KiB
C
441 lines
12 KiB
C
/* GTK - The GIMP Toolkit
|
|
* Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "gtkgradient.h"
|
|
#include "gtkcssrgbavalueprivate.h"
|
|
#include "gtkstylecontextprivate.h"
|
|
#include "gtkstyleproperties.h"
|
|
#include "gtkstylepropertiesprivate.h"
|
|
|
|
/**
|
|
* SECTION:gtkgradient
|
|
* @Short_description: Gradients
|
|
* @Title: GtkGradient
|
|
*
|
|
* GtkGradient is a boxed type that represents a gradient.
|
|
* It is the result of parsing a
|
|
* <link linkend="gtkcssprovider-gradients">gradient expression</link>.
|
|
* To obtain the gradient represented by a GtkGradient, it has to
|
|
* be resolved with gtk_gradient_resolve(), which replaces all
|
|
* symbolic color references by the colors they refer to (in a given
|
|
* context) and constructs a #cairo_pattern_t value.
|
|
*
|
|
* It is not normally necessary to deal directly with #GtkGradients,
|
|
* since they are mostly used behind the scenes by #GtkStyleContext and
|
|
* #GtkCssProvider.
|
|
*/
|
|
|
|
G_DEFINE_BOXED_TYPE (GtkGradient, gtk_gradient,
|
|
gtk_gradient_ref, gtk_gradient_unref)
|
|
|
|
typedef struct ColorStop ColorStop;
|
|
|
|
struct ColorStop
|
|
{
|
|
gdouble offset;
|
|
GtkSymbolicColor *color;
|
|
};
|
|
|
|
struct _GtkGradient
|
|
{
|
|
gdouble x0;
|
|
gdouble y0;
|
|
gdouble x1;
|
|
gdouble y1;
|
|
gdouble radius0;
|
|
gdouble radius1;
|
|
|
|
GArray *stops;
|
|
|
|
guint ref_count;
|
|
};
|
|
|
|
/**
|
|
* gtk_gradient_new_linear:
|
|
* @x0: X coordinate of the starting point
|
|
* @y0: Y coordinate of the starting point
|
|
* @x1: X coordinate of the end point
|
|
* @y1: Y coordinate of the end point
|
|
*
|
|
* Creates a new linear gradient along the line defined by (x0, y0) and (x1, y1). Before using the gradient
|
|
* a number of stop colors must be added through gtk_gradient_add_color_stop().
|
|
*
|
|
* Returns: A newly created #GtkGradient
|
|
*
|
|
* Since: 3.0
|
|
**/
|
|
GtkGradient *
|
|
gtk_gradient_new_linear (gdouble x0,
|
|
gdouble y0,
|
|
gdouble x1,
|
|
gdouble y1)
|
|
{
|
|
GtkGradient *gradient;
|
|
|
|
gradient = g_slice_new (GtkGradient);
|
|
gradient->stops = g_array_new (FALSE, FALSE, sizeof (ColorStop));
|
|
|
|
gradient->x0 = x0;
|
|
gradient->y0 = y0;
|
|
gradient->x1 = x1;
|
|
gradient->y1 = y1;
|
|
gradient->radius0 = 0;
|
|
gradient->radius1 = 0;
|
|
|
|
gradient->ref_count = 1;
|
|
|
|
return gradient;
|
|
}
|
|
|
|
/**
|
|
* gtk_gradient_new_radial:
|
|
* @x0: X coordinate of the start circle
|
|
* @y0: Y coordinate of the start circle
|
|
* @radius0: radius of the start circle
|
|
* @x1: X coordinate of the end circle
|
|
* @y1: Y coordinate of the end circle
|
|
* @radius1: radius of the end circle
|
|
*
|
|
* Creates a new radial gradient along the two circles defined by (x0, y0, radius0) and
|
|
* (x1, y1, radius1). Before using the gradient a number of stop colors must be added
|
|
* through gtk_gradient_add_color_stop().
|
|
*
|
|
* Returns: A newly created #GtkGradient
|
|
*
|
|
* Since: 3.0
|
|
**/
|
|
GtkGradient *
|
|
gtk_gradient_new_radial (gdouble x0,
|
|
gdouble y0,
|
|
gdouble radius0,
|
|
gdouble x1,
|
|
gdouble y1,
|
|
gdouble radius1)
|
|
{
|
|
GtkGradient *gradient;
|
|
|
|
gradient = g_slice_new (GtkGradient);
|
|
gradient->stops = g_array_new (FALSE, FALSE, sizeof (ColorStop));
|
|
|
|
gradient->x0 = x0;
|
|
gradient->y0 = y0;
|
|
gradient->x1 = x1;
|
|
gradient->y1 = y1;
|
|
gradient->radius0 = radius0;
|
|
gradient->radius1 = radius1;
|
|
|
|
gradient->ref_count = 1;
|
|
|
|
return gradient;
|
|
}
|
|
|
|
/**
|
|
* gtk_gradient_add_color_stop:
|
|
* @gradient: a #GtkGradient
|
|
* @offset: offset for the color stop
|
|
* @color: color to use
|
|
*
|
|
* Adds a stop color to @gradient.
|
|
*
|
|
* Since: 3.0
|
|
**/
|
|
void
|
|
gtk_gradient_add_color_stop (GtkGradient *gradient,
|
|
gdouble offset,
|
|
GtkSymbolicColor *color)
|
|
{
|
|
ColorStop stop;
|
|
|
|
g_return_if_fail (gradient != NULL);
|
|
|
|
stop.offset = offset;
|
|
stop.color = gtk_symbolic_color_ref (color);
|
|
|
|
g_array_append_val (gradient->stops, stop);
|
|
}
|
|
|
|
/**
|
|
* gtk_gradient_ref:
|
|
* @gradient: a #GtkGradient
|
|
*
|
|
* Increases the reference count of @gradient.
|
|
*
|
|
* Returns: The same @gradient
|
|
*
|
|
* Since: 3.0
|
|
**/
|
|
GtkGradient *
|
|
gtk_gradient_ref (GtkGradient *gradient)
|
|
{
|
|
g_return_val_if_fail (gradient != NULL, NULL);
|
|
|
|
gradient->ref_count++;
|
|
|
|
return gradient;
|
|
}
|
|
|
|
/**
|
|
* gtk_gradient_unref:
|
|
* @gradient: a #GtkGradient
|
|
*
|
|
* Decreases the reference count of @gradient, freeing its memory
|
|
* if the reference count reaches 0.
|
|
*
|
|
* Since: 3.0
|
|
**/
|
|
void
|
|
gtk_gradient_unref (GtkGradient *gradient)
|
|
{
|
|
g_return_if_fail (gradient != NULL);
|
|
|
|
gradient->ref_count--;
|
|
|
|
if (gradient->ref_count == 0)
|
|
{
|
|
guint i;
|
|
|
|
for (i = 0; i < gradient->stops->len; i++)
|
|
{
|
|
ColorStop *stop;
|
|
|
|
stop = &g_array_index (gradient->stops, ColorStop, i);
|
|
gtk_symbolic_color_unref (stop->color);
|
|
}
|
|
|
|
g_array_free (gradient->stops, TRUE);
|
|
g_slice_free (GtkGradient, gradient);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_gradient_resolve:
|
|
* @gradient: a #GtkGradient
|
|
* @props: #GtkStyleProperties to use when resolving named colors
|
|
* @resolved_gradient: (out): return location for the resolved pattern
|
|
*
|
|
* If @gradient is resolvable, @resolved_gradient will be filled in
|
|
* with the resolved gradient as a cairo_pattern_t, and %TRUE will
|
|
* be returned. Generally, if @gradient can't be resolved, it is
|
|
* due to it being defined on top of a named color that doesn't
|
|
* exist in @props.
|
|
*
|
|
* Returns: %TRUE if the gradient has been resolved
|
|
*
|
|
* Since: 3.0
|
|
**/
|
|
gboolean
|
|
gtk_gradient_resolve (GtkGradient *gradient,
|
|
GtkStyleProperties *props,
|
|
cairo_pattern_t **resolved_gradient)
|
|
{
|
|
cairo_pattern_t *pattern;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (gradient != NULL, FALSE);
|
|
g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
|
|
g_return_val_if_fail (resolved_gradient != NULL, FALSE);
|
|
|
|
if (gradient->radius0 == 0 && gradient->radius1 == 0)
|
|
pattern = cairo_pattern_create_linear (gradient->x0, gradient->y0,
|
|
gradient->x1, gradient->y1);
|
|
else
|
|
pattern = cairo_pattern_create_radial (gradient->x0, gradient->y0,
|
|
gradient->radius0,
|
|
gradient->x1, gradient->y1,
|
|
gradient->radius1);
|
|
|
|
for (i = 0; i < gradient->stops->len; i++)
|
|
{
|
|
ColorStop *stop;
|
|
GdkRGBA color;
|
|
|
|
stop = &g_array_index (gradient->stops, ColorStop, i);
|
|
|
|
if (!gtk_symbolic_color_resolve (stop->color, props, &color))
|
|
{
|
|
cairo_pattern_destroy (pattern);
|
|
return FALSE;
|
|
}
|
|
|
|
cairo_pattern_add_color_stop_rgba (pattern, stop->offset,
|
|
color.red, color.green,
|
|
color.blue, color.alpha);
|
|
}
|
|
|
|
*resolved_gradient = pattern;
|
|
return TRUE;
|
|
}
|
|
|
|
cairo_pattern_t *
|
|
_gtk_gradient_resolve_full (GtkGradient *gradient,
|
|
GtkStyleProviderPrivate *provider,
|
|
GtkCssComputedValues *values,
|
|
GtkCssComputedValues *parent_values,
|
|
GtkCssDependencies *dependencies)
|
|
{
|
|
cairo_pattern_t *pattern;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (gradient != NULL, NULL);
|
|
g_return_val_if_fail (GTK_IS_STYLE_PROVIDER (provider), NULL);
|
|
g_return_val_if_fail (GTK_IS_CSS_COMPUTED_VALUES (values), NULL);
|
|
g_return_val_if_fail (parent_values == NULL || GTK_IS_CSS_COMPUTED_VALUES (parent_values), NULL);
|
|
g_return_val_if_fail (*dependencies == 0, NULL);
|
|
|
|
if (gradient->radius0 == 0 && gradient->radius1 == 0)
|
|
pattern = cairo_pattern_create_linear (gradient->x0, gradient->y0,
|
|
gradient->x1, gradient->y1);
|
|
else
|
|
pattern = cairo_pattern_create_radial (gradient->x0, gradient->y0,
|
|
gradient->radius0,
|
|
gradient->x1, gradient->y1,
|
|
gradient->radius1);
|
|
|
|
for (i = 0; i < gradient->stops->len; i++)
|
|
{
|
|
ColorStop *stop;
|
|
GtkCssValue *val;
|
|
GdkRGBA rgba;
|
|
GtkCssDependencies stop_deps;
|
|
|
|
stop = &g_array_index (gradient->stops, ColorStop, i);
|
|
|
|
/* if color resolving fails, assume transparency */
|
|
val = _gtk_symbolic_color_resolve_full (stop->color,
|
|
provider,
|
|
_gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_COLOR),
|
|
GTK_CSS_DEPENDS_ON_COLOR,
|
|
&stop_deps);
|
|
if (val)
|
|
{
|
|
rgba = *_gtk_css_rgba_value_get_rgba (val);
|
|
*dependencies = _gtk_css_dependencies_union (*dependencies, stop_deps);
|
|
}
|
|
else
|
|
{
|
|
rgba.red = rgba.green = rgba.blue = rgba.alpha = 0.0;
|
|
}
|
|
|
|
cairo_pattern_add_color_stop_rgba (pattern, stop->offset,
|
|
rgba.red, rgba.green,
|
|
rgba.blue, rgba.alpha);
|
|
}
|
|
|
|
return pattern;
|
|
}
|
|
|
|
static void
|
|
append_number (GString *str,
|
|
double d,
|
|
const char *zero,
|
|
const char *half,
|
|
const char *one)
|
|
{
|
|
if (zero && d == 0.0)
|
|
g_string_append (str, zero);
|
|
else if (half && d == 0.5)
|
|
g_string_append (str, half);
|
|
else if (one && d == 1.0)
|
|
g_string_append (str, one);
|
|
else
|
|
{
|
|
char buf[G_ASCII_DTOSTR_BUF_SIZE];
|
|
|
|
g_ascii_dtostr (buf, sizeof (buf), d);
|
|
g_string_append (str, buf);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* gtk_gradient_to_string:
|
|
* @gradient: the gradient to print
|
|
*
|
|
* Creates a string representation for @gradient that is suitable
|
|
* for using in GTK CSS files.
|
|
*
|
|
* Returns: A string representation for @gradient
|
|
**/
|
|
char *
|
|
gtk_gradient_to_string (GtkGradient *gradient)
|
|
{
|
|
GString *str;
|
|
guint i;
|
|
|
|
g_return_val_if_fail (gradient != NULL, NULL);
|
|
|
|
str = g_string_new ("-gtk-gradient (");
|
|
|
|
if (gradient->radius0 == 0 && gradient->radius1 == 0)
|
|
{
|
|
g_string_append (str, "linear, ");
|
|
append_number (str, gradient->x0, "left", "center", "right");
|
|
g_string_append_c (str, ' ');
|
|
append_number (str, gradient->y0, "top", "center", "bottom");
|
|
g_string_append (str, ", ");
|
|
append_number (str, gradient->x1, "left", "center", "right");
|
|
g_string_append_c (str, ' ');
|
|
append_number (str, gradient->y1, "top", "center", "bottom");
|
|
}
|
|
else
|
|
{
|
|
g_string_append (str, "radial, ");
|
|
append_number (str, gradient->x0, "left", "center", "right");
|
|
g_string_append_c (str, ' ');
|
|
append_number (str, gradient->y0, "top", "center", "bottom");
|
|
g_string_append (str, ", ");
|
|
append_number (str, gradient->radius0, NULL, NULL, NULL);
|
|
g_string_append (str, ", ");
|
|
append_number (str, gradient->x1, "left", "center", "right");
|
|
g_string_append_c (str, ' ');
|
|
append_number (str, gradient->y1, "top", "center", "bottom");
|
|
g_string_append (str, ", ");
|
|
append_number (str, gradient->radius1, NULL, NULL, NULL);
|
|
}
|
|
|
|
for (i = 0; i < gradient->stops->len; i++)
|
|
{
|
|
ColorStop *stop;
|
|
char *s;
|
|
|
|
stop = &g_array_index (gradient->stops, ColorStop, i);
|
|
|
|
g_string_append (str, ", ");
|
|
|
|
if (stop->offset == 0.0)
|
|
g_string_append (str, "from (");
|
|
else if (stop->offset == 1.0)
|
|
g_string_append (str, "to (");
|
|
else
|
|
{
|
|
g_string_append (str, "color-stop (");
|
|
append_number (str, stop->offset, NULL, NULL, NULL);
|
|
g_string_append (str, ", ");
|
|
}
|
|
|
|
s = gtk_symbolic_color_to_string (stop->color);
|
|
g_string_append (str, s);
|
|
g_free (s);
|
|
|
|
g_string_append (str, ")");
|
|
}
|
|
|
|
g_string_append (str, ")");
|
|
|
|
return g_string_free (str, FALSE);
|
|
}
|