computedvalues: Split out a function

stylecontext: Don't queue a resize when none is needed

container: Split out a function

container: Remove duplicated flag

GtkContainer::need_resize and GtkWidget::alloc_needed are the same
thing.

container: Simplify code

This code should not have any functional changes and just be simpler.

stylecontext: Listen to the new changed signal

styleprovider: Make all implementors emit the new signal

... and listen to it in the cases where they use other style providers.

styleprovider: Add a private signal for when things change

stylecontext: Pass time to style_context_validate()

This way, we can ensure that every style context uses the same timestamp
for whatever they do.

stylecontext: Compute if things changed before invalidating

This is only a small performance boost by itself, but it's necessary
for animations, so we need it.

Benchmark numbers for my Glade benchmark for interested people:
        GTK 3.4.0    last commit  this commit
Raleigh
  real  0m41.879s    0m10.176s    0m9.900s
  user  0m41.394s    0m9.895s     0m9.628s
  sys   0m0.111s     0m0.096s     0m0.102s

Adwaita                                        (*)
  real  0m51.049s    0m13.432s    0m14.848s    0m12.253s
  user  0m50.487s    0m13.034s    0m13.218s    0m11.927s
  sys   0m0.117s     0m0.151s     0m0.147s     0m0.107s

Ambiance (patched to not use private GTK APIs)
  real  0m52.167s    0m13.115s    0m13.117s    0m12.944s
  user  0m51.576s    0m12.739s    0m12.768s    0m12.651s
  sys   0m0.119s     0m0.137s     0m0.136s     0m0.118s

(*) Adwaita and unico currently use custom properties, and
_gtk_css_value_compare() for custom properties always returns FALSE,
which makes this optimization never trigger. So I modified
_gtk_css_value_compare() to return TRUE for these properties instead and
reran the benchmark. Those are the numbers.

reftests: Fix reftests for recent changes

widget: Don't cache widget paths all the time

Add an internal API that allows GtkStyleContext to create a widget path
for the widget and with that bypassing gtk_widget_get_path() and that
  function caching the path.

stylecontext: Remove theming_engine cache variable

Instead, look up the variable upon use. This is more correct (for when
the engine changes due to save/restore() shenanigans.

And it removes code that doesn't use the standard code paths.

stylecontext: Split out a function

styleproperty: Remove equal_func vfunc

Equality tests are done with _gtk_css_value_equal(). There is no need to
do it per-property, equal values will still be equal.

This essentially reverts 24f5d54329e028347bd76af42e86ed190c1229a2 and
92c7a7171e1240b6d961ee5b6f9ab6b596e98904.

cssvalue: Split out old value handling to new typed value

... and Make this new value be a real GValue, as we don't need to save
performance for these anymore (it's just used for custom properties).
And I'd rather have code work for all values then be optimized for no
reason.

themingengine: Fix outline-width

It's a number, not an int.

shorthand: Fix border query functions

We haven't been using ints there for a while, I wonder why that never
blew up...

symboliccolor: Treat it as a CssValue

.. now that it is one.

tests: Add a test ensuring currentColor is parsed everywhere

cssprovider: Add an empty line when printing

... between the @define-color statements and the rules.

symboliccolor: Parse 'currentColor' everywhere

symboliccolor: Pass the current color to the resolve function

This way, we can resolve things like
  mix (currentColor, &otherColor);
and therefore parse currentColor as a regular color.

cssparser: Move symbolic color parser to gtksymboliccolor.c

symboliccolor: Turn this into a GtkCssValue

css: Add a shorthand 'transition' property

shorthand: Add ',' to value_is_done_parsing()

css: Remove old animation code

Deprecate public API where appropriate and make it no-ops.
Remove all calls to it.
Get rid of the 'transition' css property.

For now, this means spinners don't animate anymore.

css: Remove GtkCssNumber

It's completely replaced by GtkCssNumberValue now.

linear-gradient: Convert from GtkCssNumber to GtkCssValue

cssvalue: Convert border-image-width to border value

cssvalue: Add a border value

.. and parse border-image-slice with it.

cssvalue: Add a cssvalue for background-size

cssvalue: Add a custom value for repeats

In particular, that's background-repeat and border-image-repeat.

Also, fix up the border-image shorthand to allow any order.

cssvalue: Add a value for background-position

cssvalue: Add a css value for engines

cssstyleproperty: Convert binding sets

Instead of keeping a custom GPtrArray, keep it as a GtkCssArrayValue of
GtkCssStringValue. This way, we gain equality comparisons and print
functions for free.

cssvalue: Add a value for border-radius corner properties

... and convert those properties to this value.

css: Make outline-offset a number property

shadow: Add equal and transition support

... and enable transitions for the shadow properties.

cssvalue: Add GtkCssShadowsValue

This is necessary because shadows get treated differently from other
lists when transitioning.

tests: Add a parsing test for shadows

shadow: Rewrite to store contents as values

shadow: Make color a GtkCssValue

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.

themingengine: Make _gtk_theming_engine_paint_spinner() args const

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

stylecontext: Don't queue_resize() all the time

When a parent style context exists, there's no need to queue_resize() on
the widget, because the parent widget will call
gtk_style_context_validate() on us and _then_ we can call queue_resize()
if we have to.

cssstyleproperty: Mark all animatable properties

Only the ones that can be animated are marked of course. So more work is
needed.
This is important for
  transition-property: all;
because it'll just animate all the properties that can be.

cssstyleproperty: Add _gtk_css_style_property_is_animated()

css: Move enum to the only source file using it

cssvalue: Add transition support for images

cssimage: Add GtkCssImageCrossFade

Supports the cross-fade() css notation the way the old CSS3 specs did.

The main reason for adding it is supporting image transitions though.

cssvalue: Add _gtk_css_value_to_string()

This is a tiny wrapper around _gtk_css_value_print().
It's intended for usage in gdb and printf debugging.

cssstyleproperty: Add transition properties

cssvalue: Add GtkCssEaseValue

This is supposed to hold the transition-easing-function and
animation-easing-function values.

cssvalue: Add a GtkCssValue for idents

css: Add <time> type to css number stuff

computedvalues: Fix signage error

css: Remove _gtk_css_computed_values_get_value_by_name()

Now that we use an enum for the IDs, we don't need that function
anymore.

stylecontext: Convert _gtk_style_context_peek_property()

Take the property id instead of the name.

css: Add an enum for all the style properties

So instead of using
  _gtk_css_style_property_get_id (GTK_CSS_STYLE_PROPERTY
        (_gtk_style_property_lookup ("name")))
one can now use
  GTK_CSS_PROPERTY_NAME

Esaier, eh?

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.

cssvalue: Do a hacky conversion of font-size to a number value

Just store the value as px for now.

The font-size property needs a complete makeover anyway.

cssvalue: Convert 'font-family'

It's now a CssArrayValue filled with CssStringValue

cssvalue: Add a custom value for strings

cssprovider: Store widget style value as string

There's no need to turn it into a GtkCssValue, it's always a string.

cssvalue: Add GtkCssArea to the enum values

... and get rid of its GType.

This makes it non-queryable using gtk_style_context_get() but it used to
be a private struct anyway.

switch: Set ACTIVE state flag with is_active property

stylecontext: Keep the main style data around until revalidation

stylecontext: Keep per-styleinfo data

Instead of having one global data structure, keep it per style info.
This means that we can do special tricks on the "global" style data.

stylecontext: Make style_data_lookup() not take a state anymore

Instead, use the current state of the style context.

widget-factory: Add spinners

Doesn't look very well, but if somebody cares about that, he can fix it
(hint hint)

cssvalue: Add a cssvalue for images

cssvalue: Add enum values for the pango enums

And fix the parser to conform to the CSS spec while at it.

cssvalue: Make border styles be their own value

... and add them via gtkcssenumvalue.[ch] which will be used for all
enums.

cssvalue: Add a custom RGBA value

Note: custom CSS properties still use the default GtkCssValue and always
will.
So there is a difference in css values used between those, even though
they both carry a GdkRGBA payload.

cssstyleproperty: Make assign_value a vfunc

customproperty: Implement assign vfunc

I'm going to overwrite the GtkCssStyleProperty one, so better keep this
one.

shadow: Also rename files

shadow: Rename to GtkCssShadowValue

I don't want to confuse css values with other stuff, so there.

cssvalue: Remove unused function

shadow: Move parse function into GtkShadow

This way, we have less public API.
And gtkcssstylepropertyimpl.c looks less scary (only 1624 lines now).

shadow: Make this a GtkCssValue

shadow: Remove _gtk_shadow_get_resolved()

It's unused

stylepropertyimpl: Make shadows unqueryable

Normal APIs couldn't use GtkShadow anyway as the type was private.

theming: Use peek_property() calls to query shadows

cssvalue: Split number values into their own class

cssstyleproperty: Make query func a vfunc

This will be needed soon.

customproperty: Add our own query_value function

I'm about to change the CssStyleProperty one, so better copy things
here.

cssstyelproperty: Rempove specified-type and computed-type props

This removes the necessity to keep a GType associated with style
properties and code can now make use of GtkCssValue completely.

styleproperty: Remove default parse function

... and assert every style property brings its own.

stylepropertyimpl: Add remaining parse functions

styleproperty: Simplify compute_value function

The compute_value fallback path is only needed for custom properties,
the real style properties have custom compute functions if they need
them already.

css: Move shadow parse/print/compute funcs

They don't belong in the style funcs, as those are for custom
properties, and the shadow type is private.

stylepropertyimpl: Add parse funcs for enums

stylepropertyimpl: Add color parsing function

This is in preparation for removing the specified type and computed type
properties from GtkCssStyleProperty, which is in preparation for really
using GtkCssValue classes and not GTypes.

customproperty: Don't rely on querying style property

This way, we can remove type madness from GtkCssStyleProperty later.

styleproperty: Make gtk_style_property_register() not be valist

Instead, make the caller create a GtkCssValue in advance.

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...