From cdc5053fd9a39253e7b3b3ce55af6945dfc7ee13 Mon Sep 17 00:00:00 2001 From: Alexander Larsson Date: Tue, 4 Dec 2012 14:37:23 +0100 Subject: [PATCH] css: Introduce _gtk_css_value_needs_compute This returns TRUE for all css values that always compute to themselves and thus does not need computation. This is useful for the initial values as these are static and we can avoid computing them in a lot of cases. --- gtk/gtkcssarrayvalue.c | 15 +++++++++++++++ gtk/gtkcssbgsizevalue.c | 9 +++++++++ gtk/gtkcssbordervalue.c | 15 +++++++++++++++ gtk/gtkcsscolorvalue.c | 7 +++++++ gtk/gtkcsscornervalue.c | 9 +++++++++ gtk/gtkcsseasevalue.c | 7 +++++++ gtk/gtkcssenginevalue.c | 7 +++++++ gtk/gtkcssenumvalue.c | 22 ++++++++++++++++++++++ gtk/gtkcssimagevalue.c | 7 +++++++ gtk/gtkcssinheritvalue.c | 7 +++++++ gtk/gtkcssinitialvalue.c | 7 +++++++ gtk/gtkcssnumbervalue.c | 33 +++++++++++++++++++++++++++++++++ gtk/gtkcsspositionvalue.c | 9 +++++++++ gtk/gtkcssrepeatvalue.c | 8 ++++++++ gtk/gtkcssrgbavalue.c | 7 +++++++ gtk/gtkcssshadowsvalue.c | 15 +++++++++++++++ gtk/gtkcssshadowvalue.c | 13 +++++++++++++ gtk/gtkcssstringvalue.c | 8 ++++++++ gtk/gtkcsstypedvalue.c | 7 +++++++ gtk/gtkcssvalue.c | 21 +++++++++++++++++++++ gtk/gtkcssvalueprivate.h | 2 ++ 21 files changed, 235 insertions(+) diff --git a/gtk/gtkcssarrayvalue.c b/gtk/gtkcssarrayvalue.c index 45f1fb2c21..425c560a88 100644 --- a/gtk/gtkcssarrayvalue.c +++ b/gtk/gtkcssarrayvalue.c @@ -82,6 +82,20 @@ gtk_css_value_array_compute (GtkCssValue *value, return result; } +static gboolean +gtk_css_value_array_needs_compute (const GtkCssValue *value) +{ + guint i; + + for (i = 0; i < value->n_values; i++) + { + if (_gtk_css_value_needs_compute (value->values[i])) + return TRUE; + } + + return FALSE; +} + static gboolean gtk_css_value_array_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -323,6 +337,7 @@ gtk_css_value_array_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_ARRAY = { gtk_css_value_array_free, gtk_css_value_array_compute, + gtk_css_value_array_needs_compute, gtk_css_value_array_equal, gtk_css_value_array_transition, gtk_css_value_array_print diff --git a/gtk/gtkcssbgsizevalue.c b/gtk/gtkcssbgsizevalue.c index 662ceb7d1e..e9ef388a44 100644 --- a/gtk/gtkcssbgsizevalue.c +++ b/gtk/gtkcssbgsizevalue.c @@ -69,6 +69,14 @@ gtk_css_value_bg_size_compute (GtkCssValue *value, value->y ? y : NULL); } +static gboolean +gtk_css_value_bg_size_needs_compute (const GtkCssValue *value) +{ + return + _gtk_css_value_needs_compute (value->x) || + _gtk_css_value_needs_compute (value->y); +} + static gboolean gtk_css_value_bg_size_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -150,6 +158,7 @@ gtk_css_value_bg_size_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_BG_SIZE = { gtk_css_value_bg_size_free, gtk_css_value_bg_size_compute, + gtk_css_value_bg_size_needs_compute, gtk_css_value_bg_size_equal, gtk_css_value_bg_size_transition, gtk_css_value_bg_size_print diff --git a/gtk/gtkcssbordervalue.c b/gtk/gtkcssbordervalue.c index 62487f8f8a..c66118a706 100644 --- a/gtk/gtkcssbordervalue.c +++ b/gtk/gtkcssbordervalue.c @@ -76,6 +76,20 @@ gtk_css_value_border_compute (GtkCssValue *value, return computed; } +static gboolean +gtk_css_value_border_needs_compute (const GtkCssValue *value) +{ + guint i; + + for (i = 0; i < 4; i++) + { + if (_gtk_css_value_needs_compute (value->values[i])) + return TRUE; + } + + return FALSE; +} + static gboolean gtk_css_value_border_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -136,6 +150,7 @@ gtk_css_value_border_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_BORDER = { gtk_css_value_border_free, gtk_css_value_border_compute, + gtk_css_value_border_needs_compute, gtk_css_value_border_equal, gtk_css_value_border_transition, gtk_css_value_border_print diff --git a/gtk/gtkcsscolorvalue.c b/gtk/gtkcsscolorvalue.c index 0486e28f60..7e0ff98647 100644 --- a/gtk/gtkcsscolorvalue.c +++ b/gtk/gtkcsscolorvalue.c @@ -334,6 +334,12 @@ gtk_css_value_color_compute (GtkCssValue *value, return resolved; } +static gboolean +gtk_css_value_color_needs_compute (const GtkCssValue *value) +{ + return TRUE; +} + static gboolean gtk_css_value_color_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -449,6 +455,7 @@ gtk_css_value_color_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_COLOR = { gtk_css_value_color_free, gtk_css_value_color_compute, + gtk_css_value_color_needs_compute, gtk_css_value_color_equal, gtk_css_value_color_transition, gtk_css_value_color_print diff --git a/gtk/gtkcsscornervalue.c b/gtk/gtkcsscornervalue.c index 394675c71a..e56bf7ebea 100644 --- a/gtk/gtkcsscornervalue.c +++ b/gtk/gtkcsscornervalue.c @@ -60,6 +60,14 @@ gtk_css_value_corner_compute (GtkCssValue *corner, return _gtk_css_corner_value_new (x, y); } +static gboolean +gtk_css_value_corner_needs_compute (const GtkCssValue *corner) +{ + return + _gtk_css_value_needs_compute (corner->x) || + _gtk_css_value_needs_compute (corner->y); +} + static gboolean gtk_css_value_corner_equal (const GtkCssValue *corner1, const GtkCssValue *corner2) @@ -104,6 +112,7 @@ gtk_css_value_corner_print (const GtkCssValue *corner, static const GtkCssValueClass GTK_CSS_VALUE_CORNER = { gtk_css_value_corner_free, gtk_css_value_corner_compute, + gtk_css_value_corner_needs_compute, gtk_css_value_corner_equal, gtk_css_value_corner_transition, gtk_css_value_corner_print diff --git a/gtk/gtkcsseasevalue.c b/gtk/gtkcsseasevalue.c index 81cdea8e37..45691c5a39 100644 --- a/gtk/gtkcsseasevalue.c +++ b/gtk/gtkcsseasevalue.c @@ -60,6 +60,12 @@ gtk_css_value_ease_compute (GtkCssValue *value, return _gtk_css_value_ref (value); } +static gboolean +gtk_css_value_ease_needs_compute (const GtkCssValue *value) +{ + return FALSE; +} + static gboolean gtk_css_value_ease_equal (const GtkCssValue *ease1, const GtkCssValue *ease2) @@ -138,6 +144,7 @@ gtk_css_value_ease_print (const GtkCssValue *ease, static const GtkCssValueClass GTK_CSS_VALUE_EASE = { gtk_css_value_ease_free, gtk_css_value_ease_compute, + gtk_css_value_ease_needs_compute, gtk_css_value_ease_equal, gtk_css_value_ease_transition, gtk_css_value_ease_print diff --git a/gtk/gtkcssenginevalue.c b/gtk/gtkcssenginevalue.c index f382df9d94..b0a1a45b9c 100644 --- a/gtk/gtkcssenginevalue.c +++ b/gtk/gtkcssenginevalue.c @@ -45,6 +45,12 @@ gtk_css_value_engine_compute (GtkCssValue *value, return _gtk_css_value_ref (value); } +static gboolean +gtk_css_value_engine_needs_compute (const GtkCssValue *value) +{ + return FALSE; +} + static gboolean gtk_css_value_engine_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -80,6 +86,7 @@ gtk_css_value_engine_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_ENGINE = { gtk_css_value_engine_free, gtk_css_value_engine_compute, + gtk_css_value_engine_needs_compute, gtk_css_value_engine_equal, gtk_css_value_engine_transition, gtk_css_value_engine_print diff --git a/gtk/gtkcssenumvalue.c b/gtk/gtkcssenumvalue.c index e1f1d1c478..e45a6c4d34 100644 --- a/gtk/gtkcssenumvalue.c +++ b/gtk/gtkcssenumvalue.c @@ -48,6 +48,12 @@ gtk_css_value_enum_compute (GtkCssValue *value, return _gtk_css_value_ref (value); } +static gboolean +gtk_css_value_enum_needs_compute (const GtkCssValue *value) +{ + return FALSE; +} + static gboolean gtk_css_value_enum_equal (const GtkCssValue *enum1, const GtkCssValue *enum2) @@ -76,6 +82,7 @@ gtk_css_value_enum_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_BORDER_STYLE = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -219,9 +226,17 @@ gtk_css_value_font_size_compute (GtkCssValue *value, return _gtk_css_number_value_new (font_size, GTK_CSS_PX); } +static gboolean +gtk_css_value_font_size_needs_compute (const GtkCssValue *value) +{ + return TRUE; +} + + static const GtkCssValueClass GTK_CSS_VALUE_FONT_SIZE = { gtk_css_value_enum_free, gtk_css_value_font_size_compute, + gtk_css_value_font_size_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -276,6 +291,7 @@ _gtk_css_font_size_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_FONT_STYLE = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -324,6 +340,7 @@ _gtk_css_font_style_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -371,6 +388,7 @@ _gtk_css_font_variant_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_FONT_WEIGHT = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -439,6 +457,7 @@ _gtk_css_font_weight_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_AREA = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -493,6 +512,7 @@ _gtk_css_area_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_DIRECTION = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -548,6 +568,7 @@ _gtk_css_direction_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_PLAY_STATE = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print @@ -601,6 +622,7 @@ _gtk_css_play_state_value_get (const GtkCssValue *value) static const GtkCssValueClass GTK_CSS_VALUE_FILL_MODE = { gtk_css_value_enum_free, gtk_css_value_enum_compute, + gtk_css_value_enum_needs_compute, gtk_css_value_enum_equal, gtk_css_value_enum_transition, gtk_css_value_enum_print diff --git a/gtk/gtkcssimagevalue.c b/gtk/gtkcssimagevalue.c index dac0c2fac8..5c8979fac9 100644 --- a/gtk/gtkcssimagevalue.c +++ b/gtk/gtkcssimagevalue.c @@ -59,6 +59,12 @@ gtk_css_value_image_compute (GtkCssValue *value, return _gtk_css_image_value_new (computed); } +static gboolean +gtk_css_value_image_needs_compute (const GtkCssValue *value) +{ + return _gtk_css_image_value_get_image (value) != NULL; +} + static gboolean gtk_css_value_image_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -95,6 +101,7 @@ gtk_css_value_image_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_IMAGE = { gtk_css_value_image_free, gtk_css_value_image_compute, + gtk_css_value_image_needs_compute, gtk_css_value_image_equal, gtk_css_value_image_transition, gtk_css_value_image_print diff --git a/gtk/gtkcssinheritvalue.c b/gtk/gtkcssinheritvalue.c index 4699c8476c..21917fafe0 100644 --- a/gtk/gtkcssinheritvalue.c +++ b/gtk/gtkcssinheritvalue.c @@ -57,6 +57,12 @@ gtk_css_value_inherit_compute (GtkCssValue *value, } } +static gboolean +gtk_css_value_inherit_needs_compute (const GtkCssValue *value) +{ + return TRUE; +} + static gboolean gtk_css_value_inherit_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -83,6 +89,7 @@ gtk_css_value_inherit_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_INHERIT = { gtk_css_value_inherit_free, gtk_css_value_inherit_compute, + gtk_css_value_inherit_needs_compute, gtk_css_value_inherit_equal, gtk_css_value_inherit_transition, gtk_css_value_inherit_print diff --git a/gtk/gtkcssinitialvalue.c b/gtk/gtkcssinitialvalue.c index 4db1bb4372..f4442f1f80 100644 --- a/gtk/gtkcssinitialvalue.c +++ b/gtk/gtkcssinitialvalue.c @@ -86,6 +86,12 @@ gtk_css_value_initial_compute (GtkCssValue *value, dependencies); } +static gboolean +gtk_css_value_initial_needs_compute (const GtkCssValue *value) +{ + return TRUE; +} + static gboolean gtk_css_value_initial_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -112,6 +118,7 @@ gtk_css_value_initial_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_INITIAL = { gtk_css_value_initial_free, gtk_css_value_initial_compute, + gtk_css_value_initial_needs_compute, gtk_css_value_initial_equal, gtk_css_value_initial_transition, gtk_css_value_initial_print diff --git a/gtk/gtkcssnumbervalue.c b/gtk/gtkcssnumbervalue.c index 19a5f596ae..4993fbb280 100644 --- a/gtk/gtkcssnumbervalue.c +++ b/gtk/gtkcssnumbervalue.c @@ -123,6 +123,38 @@ gtk_css_value_number_compute (GtkCssValue *number, } } +static gboolean +gtk_css_value_number_needs_compute (const GtkCssValue *number) +{ + switch (number->unit) + { + default: + g_assert_not_reached(); + /* fall through */ + case GTK_CSS_PERCENT: + /* percentages for font sizes are computed, other percentages aren't */ + return TRUE; + case GTK_CSS_NUMBER: + case GTK_CSS_PX: + case GTK_CSS_DEG: + case GTK_CSS_S: + return FALSE; + + case GTK_CSS_PT: + case GTK_CSS_PC: + case GTK_CSS_IN: + case GTK_CSS_CM: + case GTK_CSS_MM: + case GTK_CSS_EM: + case GTK_CSS_EX: + case GTK_CSS_RAD: + case GTK_CSS_GRAD: + case GTK_CSS_TURN: + case GTK_CSS_MS: + return TRUE; + } +} + static gboolean gtk_css_value_number_equal (const GtkCssValue *number1, const GtkCssValue *number2) @@ -180,6 +212,7 @@ gtk_css_value_number_print (const GtkCssValue *number, static const GtkCssValueClass GTK_CSS_VALUE_NUMBER = { gtk_css_value_number_free, gtk_css_value_number_compute, + gtk_css_value_number_needs_compute, gtk_css_value_number_equal, gtk_css_value_number_transition, gtk_css_value_number_print diff --git a/gtk/gtkcsspositionvalue.c b/gtk/gtkcsspositionvalue.c index 8f09db72f2..a83436d061 100644 --- a/gtk/gtkcsspositionvalue.c +++ b/gtk/gtkcsspositionvalue.c @@ -60,6 +60,14 @@ gtk_css_value_position_compute (GtkCssValue *position, return _gtk_css_position_value_new (x, y); } +static gboolean +gtk_css_value_position_needs_compute (const GtkCssValue *position) +{ + return + _gtk_css_value_needs_compute (position->x) || + _gtk_css_value_needs_compute (position->y); +} + static gboolean gtk_css_value_position_equal (const GtkCssValue *position1, const GtkCssValue *position2) @@ -155,6 +163,7 @@ done: static const GtkCssValueClass GTK_CSS_VALUE_POSITION = { gtk_css_value_position_free, gtk_css_value_position_compute, + gtk_css_value_position_needs_compute, gtk_css_value_position_equal, gtk_css_value_position_transition, gtk_css_value_position_print diff --git a/gtk/gtkcssrepeatvalue.c b/gtk/gtkcssrepeatvalue.c index eda6fef423..070ec19b07 100644 --- a/gtk/gtkcssrepeatvalue.c +++ b/gtk/gtkcssrepeatvalue.c @@ -44,6 +44,12 @@ gtk_css_value_repeat_compute (GtkCssValue *value, return _gtk_css_value_ref (value); } +static gboolean +gtk_css_value_repeat_needs_compute (const GtkCssValue *value) +{ + return FALSE; +} + static gboolean gtk_css_value_repeat_equal (const GtkCssValue *repeat1, const GtkCssValue *repeat2) @@ -116,6 +122,7 @@ gtk_css_value_border_repeat_print (const GtkCssValue *repeat, static const GtkCssValueClass GTK_CSS_VALUE_BACKGROUND_REPEAT = { gtk_css_value_repeat_free, gtk_css_value_repeat_compute, + gtk_css_value_repeat_needs_compute, gtk_css_value_repeat_equal, gtk_css_value_repeat_transition, gtk_css_value_background_repeat_print @@ -124,6 +131,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_BACKGROUND_REPEAT = { static const GtkCssValueClass GTK_CSS_VALUE_BORDER_REPEAT = { gtk_css_value_repeat_free, gtk_css_value_repeat_compute, + gtk_css_value_repeat_needs_compute, gtk_css_value_repeat_equal, gtk_css_value_repeat_transition, gtk_css_value_border_repeat_print diff --git a/gtk/gtkcssrgbavalue.c b/gtk/gtkcssrgbavalue.c index fb52acefa5..507824f6a6 100644 --- a/gtk/gtkcssrgbavalue.c +++ b/gtk/gtkcssrgbavalue.c @@ -44,6 +44,12 @@ gtk_css_value_rgba_compute (GtkCssValue *value, return _gtk_css_value_ref (value); } +static gboolean +gtk_css_value_rgba_needs_compute (const GtkCssValue *value) +{ + return FALSE; +} + static gboolean gtk_css_value_rgba_equal (const GtkCssValue *rgba1, const GtkCssValue *rgba2) @@ -80,6 +86,7 @@ gtk_css_value_rgba_print (const GtkCssValue *rgba, static const GtkCssValueClass GTK_CSS_VALUE_RGBA = { gtk_css_value_rgba_free, gtk_css_value_rgba_compute, + gtk_css_value_rgba_needs_compute, gtk_css_value_rgba_equal, gtk_css_value_rgba_transition, gtk_css_value_rgba_print diff --git a/gtk/gtkcssshadowsvalue.c b/gtk/gtkcssshadowsvalue.c index 0438316935..42e53c7efb 100644 --- a/gtk/gtkcssshadowsvalue.c +++ b/gtk/gtkcssshadowsvalue.c @@ -72,6 +72,20 @@ gtk_css_value_shadows_compute (GtkCssValue *value, return result; } +static gboolean +gtk_css_value_shadows_needs_compute (const GtkCssValue *value) +{ + guint i; + + for (i = 0; i < value->len; i++) + { + if (_gtk_css_value_needs_compute (value->values[i])) + return TRUE; + } + + return FALSE; +} + static gboolean gtk_css_value_shadows_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -181,6 +195,7 @@ gtk_css_value_shadows_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_SHADOWS = { gtk_css_value_shadows_free, gtk_css_value_shadows_compute, + gtk_css_value_shadows_needs_compute, gtk_css_value_shadows_equal, gtk_css_value_shadows_transition, gtk_css_value_shadows_print diff --git a/gtk/gtkcssshadowvalue.c b/gtk/gtkcssshadowvalue.c index 618288807a..a332530029 100644 --- a/gtk/gtkcssshadowvalue.c +++ b/gtk/gtkcssshadowvalue.c @@ -94,6 +94,18 @@ gtk_css_value_shadow_compute (GtkCssValue *shadow, return gtk_css_shadow_value_new (hoffset, voffset, radius, spread, shadow->inset, color); } +static gboolean +gtk_css_value_shadow_needs_compute (const GtkCssValue *shadow) +{ + return + _gtk_css_value_needs_compute (shadow->hoffset) || + _gtk_css_value_needs_compute (shadow->voffset) || + _gtk_css_value_needs_compute (shadow->radius) || + _gtk_css_value_needs_compute (shadow->spread) || + _gtk_css_value_needs_compute (shadow->color); +} + + static gboolean gtk_css_value_shadow_equal (const GtkCssValue *shadow1, const GtkCssValue *shadow2) @@ -154,6 +166,7 @@ gtk_css_value_shadow_print (const GtkCssValue *shadow, static const GtkCssValueClass GTK_CSS_VALUE_SHADOW = { gtk_css_value_shadow_free, gtk_css_value_shadow_compute, + gtk_css_value_shadow_needs_compute, gtk_css_value_shadow_equal, gtk_css_value_shadow_transition, gtk_css_value_shadow_print diff --git a/gtk/gtkcssstringvalue.c b/gtk/gtkcssstringvalue.c index 82e7c37b6e..9729cb72e9 100644 --- a/gtk/gtkcssstringvalue.c +++ b/gtk/gtkcssstringvalue.c @@ -44,6 +44,12 @@ gtk_css_value_string_compute (GtkCssValue *value, return _gtk_css_value_ref (value); } +static gboolean +gtk_css_value_string_needs_compute (const GtkCssValue *value) +{ + return FALSE; +} + static gboolean gtk_css_value_string_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -150,6 +156,7 @@ gtk_css_value_ident_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_STRING = { gtk_css_value_string_free, gtk_css_value_string_compute, + gtk_css_value_string_needs_compute, gtk_css_value_string_equal, gtk_css_value_string_transition, gtk_css_value_string_print @@ -158,6 +165,7 @@ static const GtkCssValueClass GTK_CSS_VALUE_STRING = { static const GtkCssValueClass GTK_CSS_VALUE_IDENT = { gtk_css_value_string_free, gtk_css_value_string_compute, + gtk_css_value_string_needs_compute, gtk_css_value_string_equal, gtk_css_value_string_transition, gtk_css_value_ident_print diff --git a/gtk/gtkcsstypedvalue.c b/gtk/gtkcsstypedvalue.c index aecee31d73..9013003cf5 100644 --- a/gtk/gtkcsstypedvalue.c +++ b/gtk/gtkcsstypedvalue.c @@ -47,6 +47,12 @@ gtk_css_value_typed_compute (GtkCssValue *value, return _gtk_css_style_compute_value (provider, values, parent_values, custom->pspec->value_type, value, dependencies); } +static gboolean +gtk_css_value_typed_needs_compute (const GtkCssValue *value) +{ + return TRUE; +} + static gboolean gtk_css_value_typed_equal (const GtkCssValue *value1, const GtkCssValue *value2) @@ -73,6 +79,7 @@ gtk_css_value_typed_print (const GtkCssValue *value, static const GtkCssValueClass GTK_CSS_VALUE_TYPED = { gtk_css_value_typed_free, gtk_css_value_typed_compute, + gtk_css_value_typed_needs_compute, gtk_css_value_typed_equal, gtk_css_value_typed_transition, gtk_css_value_typed_print diff --git a/gtk/gtkcssvalue.c b/gtk/gtkcssvalue.c index 6d77cf80c9..4320c9e1a6 100644 --- a/gtk/gtkcssvalue.c +++ b/gtk/gtkcssvalue.c @@ -106,6 +106,27 @@ _gtk_css_value_compute (GtkCssValue *value, return value->class->compute (value, property_id, provider, values, parent_values, dependencies); } +/** + * _gtk_css_value_needs_compute: + * @value: the value to check or %null + * + * Checks whether a particular css value *really* needs computation. + * A lot of css values are "absolute" (like say "10 px") and never need + * any computation done. Such a value would always just return itself + * as the computed value. This can be used in some cases to avoid + * repeated computations. + * + * Returns: %false if computing this value always returns itself, %false otherwise + **/ +gboolean +_gtk_css_value_needs_compute (GtkCssValue *value) +{ + if (value == NULL) + return FALSE; + + return value->class->needs_compute (value); +} + gboolean _gtk_css_value_equal (const GtkCssValue *value1, const GtkCssValue *value2) diff --git a/gtk/gtkcssvalueprivate.h b/gtk/gtkcssvalueprivate.h index 1d2424e5f7..b4f35a41ab 100644 --- a/gtk/gtkcssvalueprivate.h +++ b/gtk/gtkcssvalueprivate.h @@ -46,6 +46,7 @@ struct _GtkCssValueClass { GtkCssComputedValues *values, GtkCssComputedValues *parent_values, GtkCssDependencies *dependencies); + gboolean (* needs_compute) (const GtkCssValue *value); gboolean (* equal) (const GtkCssValue *value1, const GtkCssValue *value2); GtkCssValue * (* transition) (GtkCssValue *start, @@ -71,6 +72,7 @@ GtkCssValue *_gtk_css_value_compute (GtkCssValue GtkCssComputedValues *values, GtkCssComputedValues *parent_values, GtkCssDependencies *dependencies); +gboolean _gtk_css_value_needs_compute (GtkCssValue *value); gboolean _gtk_css_value_equal (const GtkCssValue *value1, const GtkCssValue *value2); gboolean _gtk_css_value_equal0 (const GtkCssValue *value1,