AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
6d71f7f61b
gtk2/gtk/gtkcssarrayvalue.c

402 lines
12 KiB
C
Raw Normal View History

cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
/* GTK - The GIMP Toolkit
* Copyright (C) 2011 Red Hat, Inc.
*
* 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 "gtkcssarrayvalueprivate.h"
cssvalue: Implement transitioning arrays Or rather: Implement it for backgrounds, as the animation rules for arrays vary by property.
2012-09-03 10:52:49 +00:00
#include "gtkcssimagevalueprivate.h"
#include "gtkcssstylepropertyprivate.h"
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
#include <string.h>
struct _GtkCssValue {
GTK_CSS_VALUE_BASE
guint n_values;
GtkCssValue *values[1];
};
static void
gtk_css_value_array_free (GtkCssValue *value)
{
guint i;
for (i = 0; i < value->n_values; i++)
{
_gtk_css_value_unref (value->values[i]);
}
g_slice_free1 (sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (value->n_values - 1), value);
}
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_array_compute (GtkCssValue *value,
guint property_id,
GtkStyleProviderPrivate *provider,
GtkCssComputedValues *values,
GtkCssComputedValues *parent_values,
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
{
GtkCssValue *result;
css: Avoid allocations in gtk_css_value_array_compute Almost all array computations lead to no changes (99% in nautilus) so we avoid the upfront allocation and delay it until we know its needed. This drops the allocate/free from the profile.
2012-12-03 13:30:37 +00:00
GtkCssValue *i_value;
guint i, j;
css: Handle some more simple cases of dependencies
2012-08-25 15:22:14 +00:00
GtkCssDependencies child_deps;
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: Avoid allocations in gtk_css_value_array_compute Almost all array computations lead to no changes (99% in nautilus) so we avoid the upfront allocation and delay it until we know its needed. This drops the allocate/free from the profile.
2012-12-03 13:30:37 +00:00
result = NULL;
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
for (i = 0; i < value->n_values; i++)
{
css: Avoid allocations in gtk_css_value_array_compute Almost all array computations lead to no changes (99% in nautilus) so we avoid the upfront allocation and delay it until we know its needed. This drops the allocate/free from the profile.
2012-12-03 13:30:37 +00:00
i_value = _gtk_css_value_compute (value->values[i], property_id, provider, 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);
css: Avoid allocations in gtk_css_value_array_compute Almost all array computations lead to no changes (99% in nautilus) so we avoid the upfront allocation and delay it until we know its needed. This drops the allocate/free from the profile.
2012-12-03 13:30:37 +00:00
if (result == NULL &&
i_value != value->values[i])
{
result = _gtk_css_array_value_new_from_array (value->values, value->n_values);
for (j = 0; j < i; j++)
_gtk_css_value_ref (result->values[j]);
}
if (result != NULL)
result->values[i] = i_value;
else
_gtk_css_value_unref (i_value);
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: Avoid allocations in gtk_css_value_array_compute Almost all array computations lead to no changes (99% in nautilus) so we avoid the upfront allocation and delay it until we know its needed. This drops the allocate/free from the profile.
2012-12-03 13:30:37 +00:00
if (result == NULL)
return _gtk_css_value_ref (value);
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
return result;
}
cssvalue: Add _gtk_css_value_equal() For now, we return FALSE for all default css values, so this is not very useful. I also think of this as an optimization equal, not a guaranteed equal, because we don't even have a notion of what "equal" means. For example, for background-repeat, "repeat, repeat" and "repeat" are functionally equivalent. But the cssvalue has no idea that it's used for background-repeat. As a more complicated example, "repeat, no-repeat" and "repeat" are equal to what one sees as long as there's only one image listed background-image-source. But once you start transition'ing to an image with 2 sources, it's different...
2012-03-26 23:43:12 +00:00
static gboolean
gtk_css_value_array_equal (const GtkCssValue *value1,
const GtkCssValue *value2)
{
guint i;
if (value1->n_values != value2->n_values)
return FALSE;
for (i = 0; i < value1->n_values; i++)
{
if (!_gtk_css_value_equal (value1->values[i],
value2->values[i]))
return FALSE;
}
return TRUE;
}
cssvalue: Implement transitioning arrays Or rather: Implement it for backgrounds, as the animation rules for arrays vary by property.
2012-09-03 10:52:49 +00:00
static guint
gcd (guint a, guint b)
{
while (b != 0)
{
guint t = b;
b = a % b;
a = t;
}
return a;
}
static guint
lcm (guint a, guint b)
{
return a / gcd (a, b) * b;
}
static GtkCssValue *
gtk_css_value_array_transition_repeat (GtkCssValue *start,
GtkCssValue *end,
guint property_id,
double progress)
{
GtkCssValue **transitions;
guint i, n;
n = lcm (start->n_values, end->n_values);
transitions = g_newa (GtkCssValue *, n);
for (i = 0; i < n; i++)
{
cssvalue: Fix out-of-bounds in array transition code
2012-09-16 16:44:59 +00:00
transitions[i] = _gtk_css_value_transition (start->values[i % start->n_values],
end->values[i % end->n_values],
cssvalue: Implement transitioning arrays Or rather: Implement it for backgrounds, as the animation rules for arrays vary by property.
2012-09-03 10:52:49 +00:00
property_id,
progress);
if (transitions[i] == NULL)
{
while (i--)
_gtk_css_value_unref (transitions[i]);
return NULL;
}
}
return _gtk_css_array_value_new_from_array (transitions, n);
}
static GtkCssValue *
gtk_css_array_value_create_default_transition_value (guint property_id)
{
switch (property_id)
{
case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
return _gtk_css_image_value_new (NULL);
default:
g_return_val_if_reached (NULL);
}
}
static GtkCssValue *
gtk_css_value_array_transition_extend (GtkCssValue *start,
GtkCssValue *end,
guint property_id,
double progress)
{
GtkCssValue **transitions;
guint i, n;
n = MAX (start->n_values, end->n_values);
transitions = g_newa (GtkCssValue *, n);
for (i = 0; i < MIN (start->n_values, end->n_values); i++)
{
transitions[i] = _gtk_css_value_transition (start->values[i],
end->values[i],
property_id,
progress);
if (transitions[i] == NULL)
{
while (i--)
_gtk_css_value_unref (transitions[i]);
return NULL;
}
}
if (start->n_values != end->n_values)
{
GtkCssValue *default_value;
default_value = gtk_css_array_value_create_default_transition_value (property_id);
for (; i < start->n_values; i++)
{
transitions[i] = _gtk_css_value_transition (start->values[i],
default_value,
property_id,
progress);
if (transitions[i] == NULL)
{
while (i--)
_gtk_css_value_unref (transitions[i]);
return NULL;
}
}
for (; i < end->n_values; i++)
{
transitions[i] = _gtk_css_value_transition (default_value,
end->values[i],
property_id,
progress);
if (transitions[i] == NULL)
{
while (i--)
_gtk_css_value_unref (transitions[i]);
return NULL;
}
}
}
g_assert (i == n);
return _gtk_css_array_value_new_from_array (transitions, n);
}
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_array_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)
{
cssvalue: Implement transitioning arrays Or rather: Implement it for backgrounds, as the animation rules for arrays vary by property.
2012-09-03 10:52:49 +00:00
switch (property_id)
{
case GTK_CSS_PROPERTY_BACKGROUND_CLIP:
case GTK_CSS_PROPERTY_BACKGROUND_ORIGIN:
case GTK_CSS_PROPERTY_BACKGROUND_SIZE:
case GTK_CSS_PROPERTY_BACKGROUND_POSITION:
case GTK_CSS_PROPERTY_BACKGROUND_REPEAT:
return gtk_css_value_array_transition_repeat (start, end, property_id, progress);
case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
return gtk_css_value_array_transition_extend (start, end, property_id, progress);
case GTK_CSS_PROPERTY_COLOR:
case GTK_CSS_PROPERTY_FONT_SIZE:
case GTK_CSS_PROPERTY_BACKGROUND_COLOR:
case GTK_CSS_PROPERTY_FONT_FAMILY:
case GTK_CSS_PROPERTY_FONT_STYLE:
case GTK_CSS_PROPERTY_FONT_VARIANT:
case GTK_CSS_PROPERTY_FONT_WEIGHT:
case GTK_CSS_PROPERTY_TEXT_SHADOW:
case GTK_CSS_PROPERTY_ICON_SHADOW:
case GTK_CSS_PROPERTY_BOX_SHADOW:
case GTK_CSS_PROPERTY_MARGIN_TOP:
case GTK_CSS_PROPERTY_MARGIN_LEFT:
case GTK_CSS_PROPERTY_MARGIN_BOTTOM:
case GTK_CSS_PROPERTY_MARGIN_RIGHT:
case GTK_CSS_PROPERTY_PADDING_TOP:
case GTK_CSS_PROPERTY_PADDING_LEFT:
case GTK_CSS_PROPERTY_PADDING_BOTTOM:
case GTK_CSS_PROPERTY_PADDING_RIGHT:
case GTK_CSS_PROPERTY_BORDER_TOP_STYLE:
case GTK_CSS_PROPERTY_BORDER_TOP_WIDTH:
case GTK_CSS_PROPERTY_BORDER_LEFT_STYLE:
case GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH:
case GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE:
case GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH:
case GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE:
case GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH:
case GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS:
case GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS:
case GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS:
case GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS:
case GTK_CSS_PROPERTY_OUTLINE_STYLE:
case GTK_CSS_PROPERTY_OUTLINE_WIDTH:
case GTK_CSS_PROPERTY_OUTLINE_OFFSET:
case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
case GTK_CSS_PROPERTY_OUTLINE_COLOR:
case GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE:
case GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT:
case GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE:
case GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH:
case GTK_CSS_PROPERTY_ENGINE:
default:
/* keep all values that are not arrays here, so we get a warning if we ever turn them
* into arrays and start animating them. */
g_warning ("Don't know how to transition arrays for property '%s'",
_gtk_style_property_get_name (GTK_STYLE_PROPERTY (_gtk_css_style_property_lookup_by_id (property_id))));
case GTK_CSS_PROPERTY_TRANSITION_PROPERTY:
case GTK_CSS_PROPERTY_TRANSITION_DURATION:
case GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION:
case GTK_CSS_PROPERTY_TRANSITION_DELAY:
case GTK_CSS_PROPERTY_GTK_KEY_BINDINGS:
return NULL;
}
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
}
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
static void
gtk_css_value_array_print (const GtkCssValue *value,
GString *string)
{
guint i;
if (value->n_values == 0)
{
g_string_append (string, "none");
return;
}
for (i = 0; i < value->n_values; i++)
{
if (i > 0)
g_string_append (string, ", ");
_gtk_css_value_print (value->values[i], string);
}
}
static const GtkCssValueClass GTK_CSS_VALUE_ARRAY = {
gtk_css_value_array_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_array_compute,
cssvalue: Add _gtk_css_value_equal() For now, we return FALSE for all default css values, so this is not very useful. I also think of this as an optimization equal, not a guaranteed equal, because we don't even have a notion of what "equal" means. For example, for background-repeat, "repeat, repeat" and "repeat" are functionally equivalent. But the cssvalue has no idea that it's used for background-repeat. As a more complicated example, "repeat, no-repeat" and "repeat" are equal to what one sees as long as there's only one image listed background-image-source. But once you start transition'ing to an image with 2 sources, it's different...
2012-03-26 23:43:12 +00:00
gtk_css_value_array_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_array_transition,
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
gtk_css_value_array_print
};
GtkCssValue *
cssarrayvalue: Redo parsing arrays Does 3 things: 1) Introduce a "none" array signleton 2) Get rid of memleaks in error paths 3) Reduce code in parse funcs
2012-04-03 07:49:37 +00:00
_gtk_css_array_value_new (GtkCssValue *content)
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
{
cssvalue: Don't allow empty arrays anymore CSS arrays aren't empty, even the ones that appear empty contain one "none" element.
2012-08-29 10:37:16 +00:00
g_return_val_if_fail (content != NULL, NULL);
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
cssarrayvalue: Redo parsing arrays Does 3 things: 1) Introduce a "none" array signleton 2) Get rid of memleaks in error paths 3) Reduce code in parse funcs
2012-04-03 07:49:37 +00:00
return _gtk_css_array_value_new_from_array (&content, 1);
}
GtkCssValue *
_gtk_css_array_value_new_from_array (GtkCssValue **values,
guint n_values)
{
GtkCssValue *result;
g_return_val_if_fail (values != NULL, NULL);
g_return_val_if_fail (n_values > 0, NULL);
result = _gtk_css_value_alloc (&GTK_CSS_VALUE_ARRAY, sizeof (GtkCssValue) + sizeof (GtkCssValue *) * (n_values - 1));
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
result->n_values = n_values;
memcpy (&result->values[0], values, sizeof (GtkCssValue *) * n_values);
cssarrayvalue: Redo parsing arrays Does 3 things: 1) Introduce a "none" array signleton 2) Get rid of memleaks in error paths 3) Reduce code in parse funcs
2012-04-03 07:49:37 +00:00
return result;
}
GtkCssValue *
_gtk_css_array_value_parse (GtkCssParser *parser,
cssvalue: Make the array parser no longer parse "none" Arrays that support it, handle it themselves.
2012-08-29 10:30:33 +00:00
GtkCssValue *(* parse_func) (GtkCssParser *parser))
cssarrayvalue: Redo parsing arrays Does 3 things: 1) Introduce a "none" array signleton 2) Get rid of memleaks in error paths 3) Reduce code in parse funcs
2012-04-03 07:49:37 +00:00
{
GtkCssValue *value, *result;
GPtrArray *values;
values = g_ptr_array_new ();
do {
value = parse_func (parser);
if (value == NULL)
{
g_ptr_array_set_free_func (values, (GDestroyNotify) _gtk_css_value_unref);
g_ptr_array_free (values, TRUE);
return NULL;
}
g_ptr_array_add (values, value);
} while (_gtk_css_parser_try (parser, ",", TRUE));
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
cssarrayvalue: Redo parsing arrays Does 3 things: 1) Introduce a "none" array signleton 2) Get rid of memleaks in error paths 3) Reduce code in parse funcs
2012-04-03 07:49:37 +00:00
result = _gtk_css_array_value_new_from_array ((GtkCssValue **) values->pdata, values->len);
g_ptr_array_free (values, TRUE);
cssvalue: Add a CSS value for arrays Make the value auto-cycle its child values, so it can be used for background properties.
2012-03-26 06:30:24 +00:00
return result;
}
GtkCssValue *
_gtk_css_array_value_get_nth (const GtkCssValue *value,
guint i)
{
g_return_val_if_fail (value != NULL, NULL);
g_return_val_if_fail (value->class == &GTK_CSS_VALUE_ARRAY, NULL);
g_return_val_if_fail (value->n_values > 0, NULL);
return value->values[i % value->n_values];
}
guint
_gtk_css_array_value_get_n_values (const GtkCssValue *value)
{
g_return_val_if_fail (value != NULL, 0);
g_return_val_if_fail (value->class == &GTK_CSS_VALUE_ARRAY, 0);
return value->n_values;
}
Reference in New Issue Copy Permalink