AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
c2ff89bbe3
gtk2/gtk/gtkcssshadowvalue.c

833 lines
26 KiB
C
Raw Normal View History

shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
/* GTK - The GIMP Toolkit
* Copyright (C) 2011 Red Hat, Inc.
*
* Author: Cosimo Cecchi <cosimoc@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
Change FSF Address
2012-02-27 13:01:10 +00:00
* License along with this library. If not, see <http://www.gnu.org/licenses/>.
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
*/
#include "config.h"
shadow: Also rename files
2012-03-28 01:34:19 +00:00
#include "gtkcssshadowvalueprivate.h"
css: Redo value resolving Instead of on-demand resolvage, we now resolve during lookup. The step is done via _gtk_css_style_property_compute_value() which currently calls into _gtk_css_style_compute_value() That function has all the old resolving machinery. The only part missing for now is the handling of win32 code. It will be added back later.
2012-01-02 14:44:45 +00:00
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
#include "gtkcairoblurprivate.h"
cssvalue: Convert shadows to GtkCssColorValue
2012-11-08 16:33:53 +00:00
#include "gtkcsscolorvalueprivate.h"
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
#include "gtkcssnumbervalueprivate.h"
shadow: Make color a GtkCssValue
2012-04-03 10:07:53 +00:00
#include "gtkcssrgbavalueprivate.h"
css: Redo value resolving Instead of on-demand resolvage, we now resolve during lookup. The step is done via _gtk_css_style_property_compute_value() which currently calls into _gtk_css_style_compute_value() That function has all the old resolving machinery. The only part missing for now is the handling of win32 code. It will be added back later.
2012-01-02 14:44:45 +00:00
#include "gtkstylecontextprivate.h"
themingengine: Move actual render functions to gtkrender.c GtkThemingEngine just always calls gtk_do_render_foo(engine->priv->context, ...) now. Other than that, the code is unchanged.
2014-06-16 02:18:51 +00:00
#include "gtkrenderprivate.h"
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
#include "gtkpango.h"
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
#include <math.h>
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
struct _GtkCssValue {
GTK_CSS_VALUE_BASE
guint inset :1;
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
GtkCssValue *hoffset;
GtkCssValue *voffset;
GtkCssValue *radius;
GtkCssValue *spread;
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
shadow: Make color a GtkCssValue
2012-04-03 10:07:53 +00:00
GtkCssValue *color;
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
};
shadow: Add equal and transition support ... and enable transitions for the shadow properties.
2012-04-03 13:33:00 +00:00
static GtkCssValue * gtk_css_shadow_value_new (GtkCssValue *hoffset,
GtkCssValue *voffset,
GtkCssValue *radius,
GtkCssValue *spread,
gboolean inset,
GtkCssValue *color);
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
static void
gtk_css_value_shadow_free (GtkCssValue *shadow)
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
{
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
_gtk_css_value_unref (shadow->hoffset);
_gtk_css_value_unref (shadow->voffset);
_gtk_css_value_unref (shadow->radius);
_gtk_css_value_unref (shadow->spread);
shadow: Make color a GtkCssValue
2012-04-03 10:07:53 +00:00
_gtk_css_value_unref (shadow->color);
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
shadow: Rename to GtkCssShadowValue I don't want to confuse css values with other stuff, so there.
2012-03-28 01:31:20 +00:00
g_slice_free (GtkCssValue, shadow);
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
}
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
css: Introduce _gtk_css_value_compute() This commit is essentially a large reorganization. Instead of all value subtypes having their own compute function, there is the general _gtk_css_value_compute() function that then calls a vfunc on the subtype.
2012-07-11 04:56:07 +00:00
static GtkCssValue *
css: Huge refactoring to avoid computing wrong values 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.
2012-09-28 16:02:46 +00:00
gtk_css_value_shadow_compute (GtkCssValue *shadow,
guint property_id,
GtkStyleProviderPrivate *provider,
css: Add a scale argument to css-value compute vfunc We need to be able to compute different GtkCssImage values depending on the scale, and we need this at compute time so that we don't need to read any images other than the scale in used (to e.g. calculate the image size). GtkStyleProviderPrivate is shared for all style contexts, so its not right.
2013-06-27 16:26:05 +00:00
int scale,
cssstyle: Rename GtkCssComputedValues => GtkCssStyle This is literally just renaming of the object (and the associated source files). No other changes are in there.
2014-10-22 21:41:50 +00:00
GtkCssStyle *values,
GtkCssStyle *parent_values,
css: Huge refactoring to avoid computing wrong values 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.
2012-09-28 16:02:46 +00:00
GtkCssDependencies *dependencies)
css: Introduce _gtk_css_value_compute() This commit is essentially a large reorganization. Instead of all value subtypes having their own compute function, there is the general _gtk_css_value_compute() function that then calls a vfunc on the subtype.
2012-07-11 04:56:07 +00:00
{
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
GtkCssValue *hoffset, *voffset, *radius, *spread, *color;
GtkCssDependencies child_deps;
child_deps = 0;
css: Add a scale argument to css-value compute vfunc We need to be able to compute different GtkCssImage values depending on the scale, and we need this at compute time so that we don't need to read any images other than the scale in used (to e.g. calculate the image size). GtkStyleProviderPrivate is shared for all style contexts, so its not right.
2013-06-27 16:26:05 +00:00
hoffset = _gtk_css_value_compute (shadow->hoffset, property_id, provider, scale, values, parent_values, &child_deps);
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
*dependencies = _gtk_css_dependencies_union (*dependencies, child_deps);
child_deps = 0;
css: Add a scale argument to css-value compute vfunc We need to be able to compute different GtkCssImage values depending on the scale, and we need this at compute time so that we don't need to read any images other than the scale in used (to e.g. calculate the image size). GtkStyleProviderPrivate is shared for all style contexts, so its not right.
2013-06-27 16:26:05 +00:00
voffset = _gtk_css_value_compute (shadow->voffset, property_id, provider, scale, values, parent_values, &child_deps);
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
*dependencies = _gtk_css_dependencies_union (*dependencies, child_deps);
child_deps = 0;
css: Add a scale argument to css-value compute vfunc We need to be able to compute different GtkCssImage values depending on the scale, and we need this at compute time so that we don't need to read any images other than the scale in used (to e.g. calculate the image size). GtkStyleProviderPrivate is shared for all style contexts, so its not right.
2013-06-27 16:26:05 +00:00
radius = _gtk_css_value_compute (shadow->radius, property_id, provider, scale, values, parent_values, &child_deps);
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
*dependencies = _gtk_css_dependencies_union (*dependencies, child_deps);
child_deps = 0;
css: Add a scale argument to css-value compute vfunc We need to be able to compute different GtkCssImage values depending on the scale, and we need this at compute time so that we don't need to read any images other than the scale in used (to e.g. calculate the image size). GtkStyleProviderPrivate is shared for all style contexts, so its not right.
2013-06-27 16:26:05 +00:00
spread = _gtk_css_value_compute (shadow->spread, property_id, provider, scale, values, parent_values, &child_deps),
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
*dependencies = _gtk_css_dependencies_union (*dependencies, child_deps);
child_deps = 0;
css: Add a scale argument to css-value compute vfunc We need to be able to compute different GtkCssImage values depending on the scale, and we need this at compute time so that we don't need to read any images other than the scale in used (to e.g. calculate the image size). GtkStyleProviderPrivate is shared for all style contexts, so its not right.
2013-06-27 16:26:05 +00:00
color = _gtk_css_value_compute (shadow->color, property_id, provider, scale, values, parent_values, &child_deps);
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
*dependencies = _gtk_css_dependencies_union (*dependencies, child_deps);
return gtk_css_shadow_value_new (hoffset, voffset, radius, spread, shadow->inset, color);
css: Introduce _gtk_css_value_compute() This commit is essentially a large reorganization. Instead of all value subtypes having their own compute function, there is the general _gtk_css_value_compute() function that then calls a vfunc on the subtype.
2012-07-11 04:56:07 +00:00
}
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
static gboolean
gtk_css_value_shadow_equal (const GtkCssValue *shadow1,
const GtkCssValue *shadow2)
{
shadow: Add equal and transition support ... and enable transitions for the shadow properties.
2012-04-03 13:33:00 +00:00
return shadow1->inset == shadow2->inset
&& _gtk_css_value_equal (shadow1->hoffset, shadow2->hoffset)
&& _gtk_css_value_equal (shadow1->voffset, shadow2->voffset)
&& _gtk_css_value_equal (shadow1->radius, shadow2->radius)
&& _gtk_css_value_equal (shadow1->spread, shadow2->spread)
&& _gtk_css_value_equal (shadow1->color, shadow2->color);
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
}
cssvalue: Add _gtk_css_value_transition() Returns a value that transitions between start and end or %NULL if the values cannot be transitioned. So far, all implementations but numbers and rgba return NULL.
2012-03-30 15:47:26 +00:00
static GtkCssValue *
gtk_css_value_shadow_transition (GtkCssValue *start,
GtkCssValue *end,
cssvalue: Pass property ID to transition function This is to allow animating arrays properly. I'm not really thrilled about this solution (we leak propertys into the values again...), but it's the best I can come up with - I prefer it to having N different array types...
2012-08-30 13:51:29 +00:00
guint property_id,
cssvalue: Add _gtk_css_value_transition() Returns a value that transitions between start and end or %NULL if the values cannot be transitioned. So far, all implementations but numbers and rgba return NULL.
2012-03-30 15:47:26 +00:00
double progress)
{
shadow: Add equal and transition support ... and enable transitions for the shadow properties.
2012-04-03 13:33:00 +00:00
if (start->inset != end->inset)
return NULL;
cssvalue: Pass property ID to transition function This is to allow animating arrays properly. I'm not really thrilled about this solution (we leak propertys into the values again...), but it's the best I can come up with - I prefer it to having N different array types...
2012-08-30 13:51:29 +00:00
return gtk_css_shadow_value_new (_gtk_css_value_transition (start->hoffset, end->hoffset, property_id, progress),
_gtk_css_value_transition (start->voffset, end->voffset, property_id, progress),
_gtk_css_value_transition (start->radius, end->radius, property_id, progress),
_gtk_css_value_transition (start->spread, end->spread, property_id, progress),
shadow: Add equal and transition support ... and enable transitions for the shadow properties.
2012-04-03 13:33:00 +00:00
start->inset,
cssvalue: Pass property ID to transition function This is to allow animating arrays properly. I'm not really thrilled about this solution (we leak propertys into the values again...), but it's the best I can come up with - I prefer it to having N different array types...
2012-08-30 13:51:29 +00:00
_gtk_css_value_transition (start->color, end->color, property_id, progress));
cssvalue: Add _gtk_css_value_transition() Returns a value that transitions between start and end or %NULL if the values cannot be transitioned. So far, all implementations but numbers and rgba return NULL.
2012-03-30 15:47:26 +00:00
}
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
static void
gtk_css_value_shadow_print (const GtkCssValue *shadow,
GString *string)
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
{
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
_gtk_css_value_print (shadow->hoffset, string);
g_string_append_c (string, ' ');
_gtk_css_value_print (shadow->voffset, string);
g_string_append_c (string, ' ');
if (_gtk_css_number_value_get (shadow->radius, 100) != 0 ||
_gtk_css_number_value_get (shadow->spread, 100) != 0)
{
_gtk_css_value_print (shadow->radius, string);
g_string_append_c (string, ' ');
}
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
if (_gtk_css_number_value_get (shadow->spread, 100) != 0)
{
_gtk_css_value_print (shadow->spread, string);
g_string_append_c (string, ' ');
}
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
_gtk_css_value_print (shadow->color, string);
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
if (shadow->inset)
g_string_append (string, " inset");
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
}
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
static const GtkCssValueClass GTK_CSS_VALUE_SHADOW = {
gtk_css_value_shadow_free,
css: Introduce _gtk_css_value_compute() This commit is essentially a large reorganization. Instead of all value subtypes having their own compute function, there is the general _gtk_css_value_compute() function that then calls a vfunc on the subtype.
2012-07-11 04:56:07 +00:00
gtk_css_value_shadow_compute,
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
gtk_css_value_shadow_equal,
cssvalue: Add _gtk_css_value_transition() Returns a value that transitions between start and end or %NULL if the values cannot be transitioned. So far, all implementations but numbers and rgba return NULL.
2012-03-30 15:47:26 +00:00
gtk_css_value_shadow_transition,
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
gtk_css_value_shadow_print
};
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
static GtkCssValue *
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
gtk_css_shadow_value_new (GtkCssValue *hoffset,
GtkCssValue *voffset,
GtkCssValue *radius,
GtkCssValue *spread,
gboolean inset,
shadow: Make color a GtkCssValue
2012-04-03 10:07:53 +00:00
GtkCssValue *color)
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
{
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
GtkCssValue *retval;
retval = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_SHADOW);
retval->hoffset = hoffset;
retval->voffset = voffset;
retval->radius = radius;
retval->spread = spread;
retval->inset = inset;
shadow: Make color a GtkCssValue
2012-04-03 10:07:53 +00:00
retval->color = color;
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
return retval;
cssshadowvalue: Fix whitespace
2014-08-29 19:54:01 +00:00
}
shadow: Make this a GtkCssValue
2012-03-27 23:56:57 +00:00
shadow: Add equal and transition support ... and enable transitions for the shadow properties.
2012-04-03 13:33:00 +00:00
GtkCssValue *
_gtk_css_shadow_value_new_for_transition (GtkCssValue *target)
{
GdkRGBA transparent = { 0, 0, 0, 0 };
g_return_val_if_fail (target->class == &GTK_CSS_VALUE_SHADOW, NULL);
return gtk_css_shadow_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
_gtk_css_number_value_new (0, GTK_CSS_PX),
_gtk_css_number_value_new (0, GTK_CSS_PX),
_gtk_css_number_value_new (0, GTK_CSS_PX),
target->inset,
_gtk_css_rgba_value_new_from_rgba (&transparent));
}
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
static gboolean
value_is_done_parsing (GtkCssParser *parser)
{
return _gtk_css_parser_is_eof (parser) ||
_gtk_css_parser_begins_with (parser, ',') ||
_gtk_css_parser_begins_with (parser, ';') ||
_gtk_css_parser_begins_with (parser, '}');
}
shadow: Rename to GtkCssShadowValue I don't want to confuse css values with other stuff, so there.
2012-03-28 01:31:20 +00:00
GtkCssValue *
css: Parse text-shadow values properly We used to accept the same syntax for text-shadow and icon-shadow as we accept for box-shadow. However, box-shadow does accept a spread and the inset keyword while the others should not.
2014-06-09 23:04:55 +00:00
_gtk_css_shadow_value_parse (GtkCssParser *parser,
gboolean box_shadow_mode)
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
{
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
enum {
HOFFSET,
VOFFSET,
RADIUS,
SPREAD,
COLOR,
N_VALUES
};
GtkCssValue *values[N_VALUES] = { NULL, };
gboolean inset;
shadow: Move parse function into GtkShadow This way, we have less public API. And gtkcssstylepropertyimpl.c looks less scary (only 1624 lines now).
2012-03-28 00:25:22 +00:00
guint i;
css: Parse text-shadow values properly We used to accept the same syntax for text-shadow and icon-shadow as we accept for box-shadow. However, box-shadow does accept a spread and the inset keyword while the others should not.
2014-06-09 23:04:55 +00:00
if (box_shadow_mode)
inset = _gtk_css_parser_try (parser, "inset", TRUE);
css: Fix uninitializaed variable
2014-06-10 13:57:57 +00:00
else
inset = FALSE;
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
do
{
if (values[HOFFSET] == NULL &&
_gtk_css_parser_has_number (parser))
{
values[HOFFSET] = _gtk_css_number_value_parse (parser,
GTK_CSS_PARSE_LENGTH
| GTK_CSS_NUMBER_AS_PIXELS);
if (values[HOFFSET] == NULL)
goto fail;
values[VOFFSET] = _gtk_css_number_value_parse (parser,
GTK_CSS_PARSE_LENGTH
| GTK_CSS_NUMBER_AS_PIXELS);
if (values[VOFFSET] == NULL)
goto fail;
if (_gtk_css_parser_has_number (parser))
{
values[RADIUS] = _gtk_css_number_value_parse (parser,
GTK_CSS_PARSE_LENGTH
| GTK_CSS_POSITIVE_ONLY
| GTK_CSS_NUMBER_AS_PIXELS);
if (values[RADIUS] == NULL)
goto fail;
}
else
values[RADIUS] = _gtk_css_number_value_new (0.0, GTK_CSS_PX);
cssshadowvalue: Fix whitespace
2014-08-29 19:54:01 +00:00
css: Parse text-shadow values properly We used to accept the same syntax for text-shadow and icon-shadow as we accept for box-shadow. However, box-shadow does accept a spread and the inset keyword while the others should not.
2014-06-09 23:04:55 +00:00
if (box_shadow_mode && _gtk_css_parser_has_number (parser))
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
{
values[SPREAD] = _gtk_css_number_value_parse (parser,
GTK_CSS_PARSE_LENGTH
| GTK_CSS_NUMBER_AS_PIXELS);
if (values[SPREAD] == NULL)
goto fail;
}
else
values[SPREAD] = _gtk_css_number_value_new (0.0, GTK_CSS_PX);
}
css: Parse text-shadow values properly We used to accept the same syntax for text-shadow and icon-shadow as we accept for box-shadow. However, box-shadow does accept a spread and the inset keyword while the others should not.
2014-06-09 23:04:55 +00:00
else if (!inset && box_shadow_mode && _gtk_css_parser_try (parser, "inset", TRUE))
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
{
if (values[HOFFSET] == NULL)
goto fail;
inset = TRUE;
break;
}
else if (values[COLOR] == NULL)
{
cssvalue: Convert shadows to GtkCssColorValue
2012-11-08 16:33:53 +00:00
values[COLOR] = _gtk_css_color_value_parse (parser);
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
symboliccolor: Treat it as a CssValue .. now that it is one.
2012-04-07 04:18:03 +00:00
if (values[COLOR] == NULL)
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
goto fail;
}
else
{
/* We parsed everything and there's still stuff left?
* Pretend we didn't notice and let the normal code produce
* a 'junk at end of value' error */
goto fail;
}
}
while (values[HOFFSET] == NULL || !value_is_done_parsing (parser));
if (values[COLOR] == NULL)
cssvalue: Convert shadows to GtkCssColorValue
2012-11-08 16:33:53 +00:00
values[COLOR] = _gtk_css_color_value_new_current_color ();
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
return gtk_css_shadow_value_new (values[HOFFSET], values[VOFFSET],
values[RADIUS], values[SPREAD],
inset, values[COLOR]);
fail:
for (i = 0; i < N_VALUES; i++)
shadow: Move parse function into GtkShadow This way, we have less public API. And gtkcssstylepropertyimpl.c looks less scary (only 1624 lines now).
2012-03-28 00:25:22 +00:00
{
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
if (values[i])
_gtk_css_value_unref (values[i]);
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
}
shadow: Move parse function into GtkShadow This way, we have less public API. And gtkcssstylepropertyimpl.c looks less scary (only 1624 lines now).
2012-03-28 00:25:22 +00:00
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
return NULL;
shadow: add a GtkShadow private type This will be used as a base both for parsing text-shadow and box-shadow properties. The type is private, as there's no real use in exporting this in a public API. https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-19 18:47:17 +00:00
}
cssshadowvalue: Move the check for blurring into its own function This makes it easier to update the check later.
2014-08-29 21:48:29 +00:00
static gboolean
needs_blur (const GtkCssValue *shadow)
{
double radius = _gtk_css_number_value_get (shadow->radius, 0);
if (radius == 0.0)
return FALSE;
return TRUE;
}
cssshadowvalue: Rename shadow_key to original_cr_key shadow_key is a poor name for this, and we're going to add more user data keys, so rename it to something more indicative of what it's used for.
2014-08-30 00:33:27 +00:00
static const cairo_user_data_key_t original_cr_key;
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
static cairo_t *
gtk_css_shadow_value_start_drawing (const GtkCssValue *shadow,
cairo_t *cr)
{
Revert "blur: Use recording surface for capturing things to blur" This reverts commit f2cb8f12705ab3a36767df3430f8868ed7b29536. The patch actually didn't work for at least text. I currently have no clue why, but I suspect it requires investigating Cairo code and recording surfaces, and I'll not do that right now.
2012-09-21 16:51:46 +00:00
cairo_rectangle_int_t clip_rect;
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
cairo_surface_t *surface;
cairo_t *blur_cr;
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
gdouble radius, clip_radius;
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
cssshadowvalue: Move the check for blurring into its own function This makes it easier to update the check later.
2014-08-29 21:48:29 +00:00
if (!needs_blur (shadow))
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
return cr;
Revert "blur: Use recording surface for capturing things to blur" This reverts commit f2cb8f12705ab3a36767df3430f8868ed7b29536. The patch actually didn't work for at least text. I currently have no clue why, but I suspect it requires investigating Cairo code and recording surfaces, and I'll not do that right now.
2012-09-21 16:51:46 +00:00
gdk_cairo_get_clip_rectangle (cr, &clip_rect);
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
cssshadowvalue: Move the check for blurring into its own function This makes it easier to update the check later.
2014-08-29 21:48:29 +00:00
radius = _gtk_css_number_value_get (shadow->radius, 0);
css: Fix computation of pixels occupied by blur radius These computations were done randomly in lots of places and more often than not, they were also wrong. This function was copied (with docs) from Firefox: http://lxr.mozilla.org/mozilla-central/source/gfx/2d/Blur.cpp https://bugzilla.gnome.org/show_bug.cgi?id=723159
2014-02-03 14:56:59 +00:00
clip_radius = _gtk_cairo_blur_compute_pixels (radius);
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
/* Create a larger surface to center the blur. */
gtkcssshadowvalue: Use cairo_surface_create_similar_image Calling this on an Xlib surface allows us to keep this in SHM memory, giving it a potential speedup so we don't have to copy it to SHM memory for the Composite when we mask later.
2014-09-02 18:21:02 +00:00
surface = cairo_surface_create_similar_image (cairo_get_target (cr),
CAIRO_FORMAT_A8,
clip_rect.width + 2 * clip_radius,
clip_rect.height + 2 * clip_radius);
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
cairo_surface_set_device_offset (surface, clip_radius - clip_rect.x, clip_radius - clip_rect.y);
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
blur_cr = cairo_create (surface);
cssshadowvalue: Rename shadow_key to original_cr_key shadow_key is a poor name for this, and we're going to add more user data keys, so rename it to something more indicative of what it's used for.
2014-08-30 00:33:27 +00:00
cairo_set_user_data (blur_cr, &original_cr_key, cairo_reference (cr), (cairo_destroy_func_t) cairo_destroy);
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
if (cairo_has_current_point (cr))
{
double x, y;
cssshadowvalue: Fix whitespace
2014-08-29 19:54:01 +00:00
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
cairo_get_current_point (cr, &x, &y);
cairo_move_to (blur_cr, x, y);
}
return blur_cr;
}
static cairo_t *
gtk_css_shadow_value_finish_drawing (const GtkCssValue *shadow,
cairo_t *cr)
{
gdouble radius;
Revert "blur: Use recording surface for capturing things to blur" This reverts commit f2cb8f12705ab3a36767df3430f8868ed7b29536. The patch actually didn't work for at least text. I currently have no clue why, but I suspect it requires investigating Cairo code and recording surfaces, and I'll not do that right now.
2012-09-21 16:51:46 +00:00
cairo_t *original_cr;
cairo_surface_t *surface;
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
cssshadowvalue: Move the check for blurring into its own function This makes it easier to update the check later.
2014-08-29 21:48:29 +00:00
if (!needs_blur (shadow))
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
return cr;
cssshadowvalue: Rename shadow_key to original_cr_key shadow_key is a poor name for this, and we're going to add more user data keys, so rename it to something more indicative of what it's used for.
2014-08-30 00:33:27 +00:00
original_cr = cairo_get_user_data (cr, &original_cr_key);
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
/* Blur the surface. */
cssshadowvalue: Move the check for blurring into its own function This makes it easier to update the check later.
2014-08-29 21:48:29 +00:00
surface = cairo_get_target (cr);
radius = _gtk_css_number_value_get (shadow->radius, 0);
Revert "blur: Use recording surface for capturing things to blur" This reverts commit f2cb8f12705ab3a36767df3430f8868ed7b29536. The patch actually didn't work for at least text. I currently have no clue why, but I suspect it requires investigating Cairo code and recording surfaces, and I'll not do that right now.
2012-09-21 16:51:46 +00:00
_gtk_cairo_blur_surface (surface, radius);
gtkcssshadowvalue: Use the blur surface as a mask, instead of painting it This will make it easier to use an A8 for our blurred surface instead of a ARGB32, which makes things a lot easier and faster.
2014-07-28 20:04:09 +00:00
gdk_cairo_set_source_rgba (original_cr, _gtk_css_rgba_value_get_rgba (shadow->color));
cairo_mask_surface (original_cr, surface, 0, 0);
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
cairo_destroy (cr);
cssshadow: plug a cairo_surface_t leak We were never destroying the cairo surface we use for blurring, which would lead to a huge leak. https://bugzilla.gnome.org/show_bug.cgi?id=686209
2012-10-16 15:54:33 +00:00
cairo_surface_destroy (surface);
shadow: add code to render blurred shadows Split out the blurred shadow rendering in three steps: - creation of a surface of the appropriate size - we use the clip rectangle as a good measurement for the size, since we won't render out of it anyway - painting the unblurred shape on the surface - this is responsibility of the single shadow implementations - blur the surface and compose the result back on the original cairo_t This means we can share code between the implementations for the first and third steps; it also makes the code independent of the rendered size, so we can avoid passing down a cairo_rectangle_t with e.g. the icon coordinates.
2012-04-17 19:43:58 +00:00
return original_cr;
}
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
static const cairo_user_data_key_t radius_key;
static const cairo_user_data_key_t layout_serial_key;
G_DEFINE_QUARK (GtkCssShadowValue pango_cached_blurred_surface, pango_cached_blurred_surface)
static cairo_surface_t *
get_cached_pango_surface (PangoLayout *layout,
const GtkCssValue *shadow)
{
cairo_surface_t *cached_surface = g_object_get_qdata (G_OBJECT (layout), pango_cached_blurred_surface_quark ());
guint cached_radius, cached_serial;
guint radius, serial;
if (!cached_surface)
return NULL;
radius = _gtk_css_number_value_get (shadow->radius, 0);
cached_radius = GPOINTER_TO_UINT (cairo_surface_get_user_data (cached_surface, &radius_key));
if (radius != cached_radius)
return NULL;
serial = pango_layout_get_serial (layout);
cached_serial = GPOINTER_TO_UINT (cairo_surface_get_user_data (cached_surface, &layout_serial_key));
if (serial != cached_serial)
return NULL;
return cached_surface;
}
static cairo_surface_t *
make_blurred_pango_surface (cairo_t *existing_cr,
PangoLayout *layout,
const GtkCssValue *shadow)
{
cairo_surface_t *surface;
cairo_t *cr;
gdouble radius, clip_radius;
shadows: Respect scaled factors for cached surface
2014-10-09 23:02:34 +00:00
gdouble x_scale, y_scale;
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
PangoRectangle ink_rect;
radius = _gtk_css_number_value_get (shadow->radius, 0);
pango_layout_get_pixel_extents (layout, &ink_rect, NULL);
clip_radius = _gtk_cairo_blur_compute_pixels (radius);
shadows: Respect scaled factors for cached surface
2014-10-09 23:02:34 +00:00
x_scale = y_scale = 1;
configure.ac: Depend on cairo 1.14.0 This is needed for cairo_set_device_scale()
2014-10-25 19:23:16 +00:00
cairo_surface_get_device_scale (cairo_get_target (existing_cr), &x_scale, &y_scale);
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
surface = cairo_surface_create_similar_image (cairo_get_target (existing_cr),
CAIRO_FORMAT_A8,
shadows: Respect scaled factors for cached surface
2014-10-09 23:02:34 +00:00
x_scale * (ink_rect.width + 2 * clip_radius),
y_scale * (ink_rect.height + 2 * clip_radius));
cairo_surface_set_device_scale (surface, x_scale, y_scale);
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
cairo_surface_set_device_offset (surface, -ink_rect.x + clip_radius, -ink_rect.y + clip_radius);
cr = cairo_create (surface);
cairo_move_to (cr, 0, 0);
_gtk_pango_fill_layout (cr, layout);
shadows: Respect scaled factors for cached surface
2014-10-09 23:02:34 +00:00
_gtk_cairo_blur_surface (surface, radius * x_scale);
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
cairo_destroy (cr);
return surface;
}
static cairo_surface_t *
get_blurred_pango_surface (cairo_t *cr,
PangoLayout *layout,
const GtkCssValue *shadow)
{
cairo_surface_t *surface;
guint radius, serial;
surface = get_cached_pango_surface (layout, shadow);
if (!surface)
{
surface = make_blurred_pango_surface (cr, layout, shadow);
/* Cache the surface on the PangoLayout */
radius = _gtk_css_number_value_get (shadow->radius, 0);
cairo_surface_set_user_data (surface, &radius_key, GUINT_TO_POINTER (radius), NULL);
serial = pango_layout_get_serial (layout);
cairo_surface_set_user_data (surface, &layout_serial_key, GUINT_TO_POINTER (serial), NULL);
g_object_set_qdata_full (G_OBJECT (layout), pango_cached_blurred_surface_quark (),
surface, (GDestroyNotify) cairo_surface_destroy);
}
return surface;
}
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
void
shadow: Rename to GtkCssShadowValue I don't want to confuse css values with other stuff, so there.
2012-03-28 01:31:20 +00:00
_gtk_css_shadow_value_paint_layout (const GtkCssValue *shadow,
cairo_t *cr,
PangoLayout *layout)
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
{
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
g_return_if_fail (shadow->class == &GTK_CSS_VALUE_SHADOW);
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
shadow: Redo shadow implementation for rotations The shadows went bonkers when the labels were rotated
2011-05-22 02:24:23 +00:00
if (!cairo_has_current_point (cr))
cairo_move_to (cr, 0, 0);
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_save (cr);
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
if (needs_blur (shadow))
{
cairo_surface_t *blurred_surface = get_blurred_pango_surface (cr, layout, shadow);
double x, y;
cairo_get_current_point (cr, &x, &y);
cairo_translate (cr, x, y);
cairo_translate (cr,
_gtk_css_number_value_get (shadow->hoffset, 0),
_gtk_css_number_value_get (shadow->voffset, 0));
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
cssshadowvalue: Add a cache for blurred Pango layouts Drawing text with Pango is quite expensive, and drawing text and also blurring it is *really* expensive. To prevent us from drawing a lot of text and then blurring it a lot is *really* expensive. We now cache the blurred pixels for the last layout and shadow we made, which means we can repeatedly draw labels with a blurred text-shadow extremely fast. To detect whether the shadow is up-to-date, we track the serial of the PangoLayout alongside the radius of the box shadow. We don't support inset shadows nor spread on text-shadow, so we don't need to track these.
2014-08-29 20:51:30 +00:00
gdk_cairo_set_source_rgba (cr, _gtk_css_rgba_value_get_rgba (shadow->color));
cairo_mask_surface (cr, blurred_surface, 0, 0);
}
else
{
/* The no blur case -- just paint directly. */
cairo_rel_move_to (cr,
_gtk_css_number_value_get (shadow->hoffset, 0),
_gtk_css_number_value_get (shadow->voffset, 0));
gdk_cairo_set_source_rgba (cr, _gtk_css_rgba_value_get_rgba (shadow->color));
_gtk_pango_fill_layout (cr, layout);
cairo_rel_move_to (cr,
- _gtk_css_number_value_get (shadow->hoffset, 0),
- _gtk_css_number_value_get (shadow->voffset, 0));
}
shadow: add blur to text-shadow
2012-04-17 20:14:39 +00:00
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_restore (cr);
shadow: add a method to paint the shadow for a PangoLayout https://bugzilla.gnome.org/show_bug.cgi?id=649314
2011-05-20 20:05:57 +00:00
}
shadow: add _gtk_icon_shadow_paint() Paints a shadow of the current source, using the defined colors.
2011-05-21 03:51:16 +00:00
void
shadow: Rename to GtkCssShadowValue I don't want to confuse css values with other stuff, so there.
2012-03-28 01:31:20 +00:00
_gtk_css_shadow_value_paint_icon (const GtkCssValue *shadow,
cairo_t *cr)
shadow: add _gtk_icon_shadow_paint() Paints a shadow of the current source, using the defined colors.
2011-05-21 03:51:16 +00:00
{
cairo_pattern_t *pattern;
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
g_return_if_fail (shadow->class == &GTK_CSS_VALUE_SHADOW);
shadow: add _gtk_icon_shadow_paint() Paints a shadow of the current source, using the defined colors.
2011-05-21 03:51:16 +00:00
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_save (cr);
pattern = cairo_pattern_reference (cairo_get_source (cr));
shadow: add blur to icon-shadow (icon)
2012-04-16 12:02:59 +00:00
shadow: Make color a GtkCssValue
2012-04-03 10:07:53 +00:00
gdk_cairo_set_source_rgba (cr, _gtk_css_rgba_value_get_rgba (shadow->color));
gtkcssshadowvalue: Don't double-apply the alpha to shadows It turns out that when we were painting the shadows, we painted the them with the base color once, which contained the alpha, and then blurred it and used it as a mask for the fill, which has the fill again. To fix this, always paint the base surface with full alpha. The existing code applies the blur conditionally sometimes in weird ways, so the code shuffling fix may not look correct, but be assured it is. If the blur happens, the new cr we return has the *default* color applied, which is fully opaque black, which works perfectly against the A8 surface. The fallback spinner code needs some modification, since it is intentionally using the alpha to paint the lobes which are "in the past". Since we shouldn't be hitting this fallback path very often, we use a temporary group and paint it with paint_with_alpha, even though it is slow.
2014-07-31 16:27:46 +00:00
cr = gtk_css_shadow_value_start_drawing (shadow, cr);
shadow: add _gtk_icon_shadow_paint() Paints a shadow of the current source, using the defined colors.
2011-05-21 03:51:16 +00:00
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
cairo_translate (cr,
_gtk_css_number_value_get (shadow->hoffset, 0),
_gtk_css_number_value_get (shadow->voffset, 0));
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_mask (cr, pattern);
shadow: add _gtk_icon_shadow_paint() Paints a shadow of the current source, using the defined colors.
2011-05-21 03:51:16 +00:00
shadow: add blur to icon-shadow (icon)
2012-04-16 12:02:59 +00:00
cr = gtk_css_shadow_value_finish_drawing (shadow, cr);
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_restore (cr);
cairo_pattern_destroy (pattern);
shadow: add _gtk_icon_shadow_paint() Paints a shadow of the current source, using the defined colors.
2011-05-21 03:51:16 +00:00
}
shadow: render icon-shadow for spinners
2011-06-06 15:38:45 +00:00
void
shadow: Rename to GtkCssShadowValue I don't want to confuse css values with other stuff, so there.
2012-03-28 01:31:20 +00:00
_gtk_css_shadow_value_paint_spinner (const GtkCssValue *shadow,
cairo_t *cr,
gdouble radius,
gdouble progress)
shadow: render icon-shadow for spinners
2011-06-06 15:38:45 +00:00
{
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
g_return_if_fail (shadow->class == &GTK_CSS_VALUE_SHADOW);
shadow: render icon-shadow for spinners
2011-06-06 15:38:45 +00:00
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_save (cr);
shadow: render icon-shadow for spinners
2011-06-06 15:38:45 +00:00
gtkcssshadowvalue: Don't double-apply the alpha to shadows It turns out that when we were painting the shadows, we painted the them with the base color once, which contained the alpha, and then blurred it and used it as a mask for the fill, which has the fill again. To fix this, always paint the base surface with full alpha. The existing code applies the blur conditionally sometimes in weird ways, so the code shuffling fix may not look correct, but be assured it is. If the blur happens, the new cr we return has the *default* color applied, which is fully opaque black, which works perfectly against the A8 surface. The fallback spinner code needs some modification, since it is intentionally using the alpha to paint the lobes which are "in the past". Since we shouldn't be hitting this fallback path very often, we use a temporary group and paint it with paint_with_alpha, even though it is slow.
2014-07-31 16:27:46 +00:00
gdk_cairo_set_source_rgba (cr, _gtk_css_rgba_value_get_rgba (shadow->color));
shadow: add blur to icon-shadow (spinner)
2012-04-16 12:22:18 +00:00
cr = gtk_css_shadow_value_start_drawing (shadow, cr);
shadow: Rewrite to store contents as values
2012-04-03 11:29:29 +00:00
cairo_translate (cr,
_gtk_css_number_value_get (shadow->hoffset, 0),
_gtk_css_number_value_get (shadow->voffset, 0));
themingengine: Move actual render functions to gtkrender.c GtkThemingEngine just always calls gtk_do_render_foo(engine->priv->context, ...) now. Other than that, the code is unchanged.
2014-06-16 02:18:51 +00:00
gtk_render_paint_spinner (cr, radius, progress);
shadow: render icon-shadow for spinners
2011-06-06 15:38:45 +00:00
shadow: add blur to icon-shadow (spinner)
2012-04-16 12:22:18 +00:00
cr = gtk_css_shadow_value_finish_drawing (shadow, cr);
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
cairo_restore (cr);
shadow: render icon-shadow for spinners
2011-06-06 15:38:45 +00:00
}
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
cds: enable outset shadows Adds conditional code paths to GdkCssShadowValue for painting outset shadows, and allows shadows to be applied in two passes (first outset then inset). This can be used to draw csd shadows in outer window borders. https://bugzilla.gnome.org/show_bug.cgi?id=695998 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-04-05 09:54:03 +00:00
gboolean
_gtk_css_shadow_value_get_inset (const GtkCssValue *shadow)
{
g_return_val_if_fail (shadow->class == &GTK_CSS_VALUE_SHADOW, FALSE);
return shadow->inset;
}
cssshadow: add a method to get the size of a shadows value The method returns the size of each side of a GtkCssShadowsValue.
2013-04-22 20:50:39 +00:00
void
_gtk_css_shadow_value_get_geometry (const GtkCssValue *shadow,
gdouble *hoffset,
gdouble *voffset,
gdouble *radius,
gdouble *spread)
{
g_return_if_fail (shadow->class == &GTK_CSS_VALUE_SHADOW);
if (hoffset != NULL)
*hoffset = _gtk_css_number_value_get (shadow->hoffset, 0);
if (voffset != NULL)
*voffset = _gtk_css_number_value_get (shadow->voffset, 0);
if (radius != NULL)
*radius = _gtk_css_number_value_get (shadow->radius, 0);
if (spread != NULL)
*spread = _gtk_css_number_value_get (shadow->spread, 0);
}
css shadows: Exit early if clip is empty
2013-05-06 10:34:09 +00:00
static gboolean
has_empty_clip (cairo_t *cr)
{
double x1, y1, x2, y2;
cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
return x1 == x2 && y1 == y2;
}
GtkCssShadowValue: Break out the shadow rendering code This makes it easier to call it multiple times which we want to do later.
2013-05-06 07:48:10 +00:00
static void
draw_shadow (const GtkCssValue *shadow,
cairo_t *cr,
GtkRoundedBox *box,
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
GtkRoundedBox *clip_box,
gboolean blur)
GtkCssShadowValue: Break out the shadow rendering code This makes it easier to call it multiple times which we want to do later.
2013-05-06 07:48:10 +00:00
{
cairo_t *shadow_cr;
css shadows: Exit early if clip is empty
2013-05-06 10:34:09 +00:00
if (has_empty_clip (cr))
return;
gtkcssshadowvalue: Don't double-apply the alpha to shadows It turns out that when we were painting the shadows, we painted the them with the base color once, which contained the alpha, and then blurred it and used it as a mask for the fill, which has the fill again. To fix this, always paint the base surface with full alpha. The existing code applies the blur conditionally sometimes in weird ways, so the code shuffling fix may not look correct, but be assured it is. If the blur happens, the new cr we return has the *default* color applied, which is fully opaque black, which works perfectly against the A8 surface. The fallback spinner code needs some modification, since it is intentionally using the alpha to paint the lobes which are "in the past". Since we shouldn't be hitting this fallback path very often, we use a temporary group and paint it with paint_with_alpha, even though it is slow.
2014-07-31 16:27:46 +00:00
gdk_cairo_set_source_rgba (cr, _gtk_css_rgba_value_get_rgba (shadow->color));
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
if (blur)
shadow_cr = gtk_css_shadow_value_start_drawing (shadow, cr);
else
shadow_cr = cr;
GtkCssShadowValue: Break out the shadow rendering code This makes it easier to call it multiple times which we want to do later.
2013-05-06 07:48:10 +00:00
cairo_set_fill_rule (shadow_cr, CAIRO_FILL_RULE_EVEN_ODD);
_gtk_rounded_box_path (box, shadow_cr);
if (shadow->inset)
_gtk_rounded_box_clip_path (clip_box, shadow_cr);
cairo_fill (shadow_cr);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
if (blur)
gtk_css_shadow_value_finish_drawing (shadow, shadow_cr);
GtkCssShadowValue: Break out the shadow rendering code This makes it easier to call it multiple times which we want to do later.
2013-05-06 07:48:10 +00:00
}
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
void
shadow: Rename to GtkCssShadowValue I don't want to confuse css values with other stuff, so there.
2012-03-28 01:31:20 +00:00
_gtk_css_shadow_value_paint_box (const GtkCssValue *shadow,
cairo_t *cr,
const GtkRoundedBox *padding_box)
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
{
shadow: add blur to box-shadow
2012-04-16 11:02:41 +00:00
GtkRoundedBox box, clip_box;
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
double spread, radius, clip_radius, x, y, outside;
css: Avoid excessive shadow rendering The shadow rendering code had code to exit early if we determine that the shadow is entirely clipped away. Unfortunately, the check based on cairo clip extents fails for any clip regions that are more complicated than axis-aligned rectangles, and we are using a hollow rounded rectangle here. So, instead, do the check manually, using the just-introduced API in GtkRoundedBox.
2014-12-02 13:29:24 +00:00
double x1, y1, x2, y2;
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
g_return_if_fail (shadow->class == &GTK_CSS_VALUE_SHADOW);
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
css: Avoid excessive shadow rendering The shadow rendering code had code to exit early if we determine that the shadow is entirely clipped away. Unfortunately, the check based on cairo clip extents fails for any clip regions that are more complicated than axis-aligned rectangles, and we are using a hollow rounded rectangle here. So, instead, do the check manually, using the just-introduced API in GtkRoundedBox.
2014-12-02 13:29:24 +00:00
cairo_clip_extents (cr, &x1, &y1, &x2, &y2);
if ((shadow->inset && !_gtk_rounded_box_intersects_rectangle (padding_box, x1, y1, x2, y2)) ||
(!shadow->inset && _gtk_rounded_box_contains_rectangle (padding_box, x1, y1, x2, y2)))
return;
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
cairo_save (cr);
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
spread = _gtk_css_number_value_get (shadow->spread, 0);
radius = _gtk_css_number_value_get (shadow->radius, 0);
css: Fix computation of pixels occupied by blur radius These computations were done randomly in lots of places and more often than not, they were also wrong. This function was copied (with docs) from Firefox: http://lxr.mozilla.org/mozilla-central/source/gfx/2d/Blur.cpp https://bugzilla.gnome.org/show_bug.cgi?id=723159
2014-02-03 14:56:59 +00:00
clip_radius = _gtk_cairo_blur_compute_pixels (radius);
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
x = _gtk_css_number_value_get (shadow->hoffset, 0);
y = _gtk_css_number_value_get (shadow->voffset, 0);
cds: enable outset shadows Adds conditional code paths to GdkCssShadowValue for painting outset shadows, and allows shadows to be applied in two passes (first outset then inset). This can be used to draw csd shadows in outer window borders. https://bugzilla.gnome.org/show_bug.cgi?id=695998 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-04-05 09:54:03 +00:00
if (shadow->inset)
{
_gtk_rounded_box_path (padding_box, cr);
cairo_clip (cr);
}
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
else
{
cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
_gtk_rounded_box_path (padding_box, cr);
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
outside = spread + clip_radius + MAX (fabs (x), fabs (y));
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
clip_box = *padding_box;
_gtk_rounded_box_grow (&clip_box, outside, outside, outside, outside);
_gtk_rounded_box_clip_path (&clip_box, cr);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
cairo_clip (cr);
}
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
cssvalue: Make GtkCssShadowValue only hold one shadow All the properties now are a GtkCssArrayValue of GtkCssSadowValue. GtkCssArrayValue already does everything we want, so no need to duplicate its funtionality.
2012-04-03 09:49:46 +00:00
box = *padding_box;
css: Clip outset box-shadow to outside of box As per css3-background 7.2. Drop Shadows: the ‘box-shadow’ property: An outer box-shadow casts a shadow as if the border-box of the element were opaque. The shadow is drawn outside the border edge only: it is clipped inside the border-box of the element. Also verified vs firefox behaviour.
2013-05-03 10:50:18 +00:00
_gtk_rounded_box_move (&box, x, y);
cds: enable outset shadows Adds conditional code paths to GdkCssShadowValue for painting outset shadows, and allows shadows to be applied in two passes (first outset then inset). This can be used to draw csd shadows in outer window borders. https://bugzilla.gnome.org/show_bug.cgi?id=695998 Signed-off-by: Rob Bradford <rob@linux.intel.com>
2013-04-05 09:54:03 +00:00
if (shadow->inset)
_gtk_rounded_box_shrink (&box, spread, spread, spread, spread);
else /* Outset */
_gtk_rounded_box_grow (&box, spread, spread, spread, spread);
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
shadow: add blur to box-shadow
2012-04-16 11:02:41 +00:00
clip_box = *padding_box;
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
_gtk_rounded_box_shrink (&clip_box, -clip_radius, -clip_radius, -clip_radius, -clip_radius);
shadow: add blur to box-shadow
2012-04-16 11:02:41 +00:00
cssshadowvalue: Move the check for blurring into its own function This makes it easier to update the check later.
2014-08-29 21:48:29 +00:00
if (!needs_blur (shadow))
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
draw_shadow (shadow, cr, &box, &clip_box, FALSE);
else
{
int i, x1, x2, y1, y2;
cairo_region_t *remaining;
cairo_rectangle_int_t r;
/* For the blurred case we divide the rendering into 9 parts,
* 4 of the corners, 4 for the horizonat/vertical lines and
* one for the interior. We make the non-interior parts
* large enought to fit the full radius of the blur, so that
* the interior part can be drawn solidly.
*/
if (shadow->inset)
{
/* In the inset case we want to paint the whole clip-box.
* We could remove the part of "box" where the blur doesn't
* reach, but computing that is a bit tricky since the
* rounded corners are on the "inside" of it. */
r.x = floor (clip_box.box.x);
r.y = floor (clip_box.box.y);
r.width = ceil (clip_box.box.x + clip_box.box.width) - r.x;
r.height = ceil (clip_box.box.y + clip_box.box.height) - r.y;
remaining = cairo_region_create_rectangle (&r);
}
else
{
/* In the outset case we want to paint the entire box, plus as far
* as the radius reaches from it */
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
r.x = floor (box.box.x - clip_radius);
r.y = floor (box.box.y - clip_radius);
r.width = ceil (box.box.x + box.box.width + clip_radius) - r.x;
r.height = ceil (box.box.y + box.box.height + clip_radius) - r.y;
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
remaining = cairo_region_create_rectangle (&r);
}
/* First do the corners of box */
for (i = 0; i < 4; i++)
{
if (i == GTK_CSS_TOP_LEFT || i == GTK_CSS_BOTTOM_LEFT)
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
x1 = floor (box.box.x - clip_radius);
x2 = ceil (box.box.x + box.corner[i].horizontal + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
else
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
x1 = floor (box.box.x + box.box.width - box.corner[i].horizontal - clip_radius);
x2 = ceil (box.box.x + box.box.width + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
if (i == GTK_CSS_TOP_LEFT || i == GTK_CSS_TOP_RIGHT)
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
y1 = floor (box.box.y - clip_radius);
y2 = ceil (box.box.y + box.corner[i].vertical + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
else
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
y1 = floor (box.box.y + box.box.height - box.corner[i].vertical - clip_radius);
y2 = ceil (box.box.y + box.box.height + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
cairo_save (cr);
cairo_rectangle (cr, x1, y1, x2 - x1, y2 - y1);
cairo_clip (cr);
/* Also clip with remaining to ensure we never draw any area twice */
gdk_cairo_region (cr, remaining);
cairo_clip (cr);
draw_shadow (shadow, cr, &box, &clip_box, TRUE);
cairo_restore (cr);
/* We drew the region, remove it from remaining */
r.x = x1;
r.y = y1;
r.width = x2 - x1;
r.height = y2 - y1;
cairo_region_subtract_rectangle (remaining, &r);
}
/* Then the sides */
for (i = 0; i < 4; i++)
{
if (i == GTK_CSS_TOP || i == GTK_CSS_BOTTOM)
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
x1 = floor (box.box.x - clip_radius);
x2 = ceil (box.box.x + box.box.width + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
else if (i == GTK_CSS_LEFT)
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
x1 = floor (box.box.x -clip_radius);
x2 = ceil (box.box.x + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
else
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
x1 = floor (box.box.x + box.box.width -clip_radius);
x2 = ceil (box.box.x + box.box.width + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
if (i == GTK_CSS_LEFT || i == GTK_CSS_RIGHT)
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
y1 = floor (box.box.y - clip_radius);
y2 = ceil (box.box.y + box.box.height + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
else if (i == GTK_CSS_TOP)
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
y1 = floor (box.box.y -clip_radius);
y2 = ceil (box.box.y + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
else
{
css shadow: Add extra slop to the blur clipping Turns out our blurring function isn't very nice, it has a lot of energy past the blur radius, so clipping at exactly the blur radius causes ugly gradient stops. This just adds 4 extra pixels of slop, which makes this better in most cases.
2013-05-06 14:05:08 +00:00
y1 = floor (box.box.y + box.box.height -clip_radius);
y2 = ceil (box.box.y + box.box.height + clip_radius);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
cairo_save (cr);
cairo_rectangle (cr, x1, y1, x2 - x1, y2 - y1);
cairo_clip (cr);
/* Also clip with remaining to ensure we never draw any area twice */
gdk_cairo_region (cr, remaining);
cairo_clip (cr);
draw_shadow (shadow, cr, &box, &clip_box, TRUE);
cairo_restore (cr);
/* We drew the region, remove it from remaining */
r.x = x1;
r.y = y1;
r.width = x2 - x1;
r.height = y2 - y1;
cairo_region_subtract_rectangle (remaining, &r);
}
/* Then the rest, which needs no blurring */
cairo_save (cr);
gdk_cairo_region (cr, remaining);
cairo_clip (cr);
draw_shadow (shadow, cr, &box, &clip_box, FALSE);
cairo_restore (cr);
css shadow: Fix memory leak https://bugzilla.gnome.org/show_bug.cgi?id=706493
2013-08-21 10:56:21 +00:00
cairo_region_destroy (remaining);
css shadows: Split up rendering of shadows We split up the rendering of blurred shadows into 9 parts, the corners, the sides and the rest. This lets us only blur the "blurry" part, and it lets us completely skip blurry parts that are fully clipped.
2013-05-06 11:06:13 +00:00
}
shadow: add blur to box-shadow
2012-04-16 11:02:41 +00:00
shadow: add _gtk_box_shadow_render() This supports only inset box-shadow elements for now.
2011-06-02 00:58:53 +00:00
cairo_restore (cr);
}
Reference in New Issue Copy Permalink